fhir-types 0.1.109

// @generated by fhir-codegen from hl7.fhir.r3.core 3.0.2. DO NOT EDIT.
// Change the emitter (tools/fhir-codegen) and regenerate.
// SPDX-FileCopyrightText: Cadasto B.V.
// SPDX-License-Identifier: Apache-2.0
//! Information about a biological sequence

/// Information about a biological sequence
///
/// Raw data describing a biological sequence.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Sequence {
    /// Logical id of this artifact
    ///
    /// The logical id of the resource, as used in the URL for the resource. Once
    /// assigned, this value never changes.
    pub id: Option<super::primitives::Id>,
    /// Metadata about the resource
    ///
    /// The metadata about the resource. This is content that is maintained by the
    /// infrastructure. Changes to the content may not always be associated with
    /// version changes to the resource.
    pub meta: Option<super::meta::Meta>,
    /// A set of rules under which this content was created
    ///
    /// A reference to a set of rules that were followed when the resource was
    /// constructed, and which must be understood when processing the content.
    pub implicit_rules: Option<super::primitives::Uri>,
    /// Language of the resource content
    ///
    /// The base language in which the resource is written.
    pub language: Option<super::primitives::Code>,
    /// Text summary of the resource, for human interpretation
    ///
    /// A human-readable narrative that contains a summary of the resource, and may
    /// be used to represent the content of the resource to a human. The narrative
    /// need not encode all the structured data, but is required to contain
    /// sufficient detail to make it "clinically safe" for a human to just read the
    /// narrative. Resource definitions may define what content should be
    /// represented in the narrative to ensure clinical safety.
    pub text: Option<super::narrative::Narrative>,
    /// Contained, inline Resources
    ///
    /// These resources do not have an independent existence apart from the resource
    /// that contains them - they cannot be identified independently, and nor can
    /// they have their own independent transaction scope.
    pub contained: Vec<super::resource::Resource>,
    /// Additional Content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the resource. In order to make the use of extensions
    /// safe and manageable, there is a strict set of governance applied to the
    /// definition and use of extensions. Though any implementer is allowed to
    /// define an extension, there is a set of requirements that SHALL be met as
    /// part of the definition of the extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the resource, and that modifies the understanding of the
    /// element that contains it. Usually modifier elements provide negation or
    /// qualification. In order to make the use of extensions safe and manageable,
    /// there is a strict set of governance applied to the definition and use of
    /// extensions. Though any implementer is allowed to define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension. Applications processing a resource are required to check for
    /// modifier extensions.
    pub modifier_extension: Vec<super::extension::Extension>,
    /// Unique ID for this particular sequence. This is a FHIR-defined id
    ///
    /// A unique identifier for this particular sequence instance. This is a
    /// FHIR-defined id.
    pub identifier: Vec<super::identifier::Identifier>,
    /// aa | dna | rna
    ///
    /// Amino Acid Sequence/ DNA Sequence / RNA Sequence.
    pub r#type: Option<super::primitives::Code>,
    /// 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)
    ///
    /// Whether the sequence is numbered starting at 0 (0-based numbering or
    /// coordinates, inclusive start, exclusive end) or starting at 1 (1-based
    /// numbering, inclusive start and inclusive end).
    pub coordinate_system: super::primitives::Integer,
    /// Who and/or what this is about
    ///
    /// The patient whose sequencing results are described by this resource.
    pub patient: Option<super::reference::Reference>,
    /// Specimen used for sequencing.
    pub specimen: Option<super::reference::Reference>,
    /// The method for sequencing
    ///
    /// The method for sequencing, for example, chip information.
    pub device: Option<super::reference::Reference>,
    /// Who should be responsible for test result
    ///
    /// The organization or lab that should be responsible for this result.
    pub performer: Option<super::reference::Reference>,
    /// The number of copies of the seqeunce of interest. (RNASeq).
    pub quantity: Option<super::quantity::Quantity>,
    /// A sequence used as reference
    ///
    /// A sequence that is used as a reference to describe variants that are present
    /// in a sequence analyzed.
    pub reference_seq: Option<SequenceReferenceSeq>,
    /// Variant in sequence
    ///
    /// The definition of variant here originates from Sequence ontology
    /// (\[variant\_of\](<http://www.sequenceontology.org/browser/current_svn/term/variant_of>)).
    /// This element can represent amino acid or nucleic sequence change(including
    /// insertion,deletion,SNP,etc.) It can represent some complex mutation or
    /// segment variation with the assist of CIGAR string.
    pub variant: Vec<SequenceVariant>,
    /// Sequence that was observed
    ///
    /// Sequence that was observed. It is the result marked by referenceSeq along
    /// with variant records on referenceSeq. This shall starts from
    /// referenceSeq.windowStart and end by referenceSeq.windowEnd.
    pub observed_seq: Option<super::primitives::String>,
    /// An set of value as quality of sequence
    ///
    /// An experimental feature attribute that defines the quality of the feature in
    /// a quantitative way, such as a phred quality score
    /// (\[SO:0001686\](<http://www.sequenceontology.org/browser/current_svn/term/SO:0001686>)).
    pub quality: Vec<SequenceQuality>,
    /// Average number of reads representing a given nucleotide in the reconstructed
    /// sequence
    ///
    /// Coverage (read depth or depth) is the average number of reads representing a
    /// given nucleotide in the reconstructed sequence.
    pub read_coverage: Option<super::primitives::Integer>,
    /// External repository which contains detailed report related with observedSeq
    /// in this resource
    ///
    /// Configurations of the external repository. The repository shall store
    /// target's observedSeq or records related with target's observedSeq.
    pub repository: Vec<SequenceRepository>,
    /// Pointer to next atomic sequence
    ///
    /// Pointer to next atomic sequence which at most contains one variant.
    pub pointer: Vec<super::reference::Reference>,
}

impl super::super::codec::Json for Sequence {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        object.insert(
            std::string::String::from("resourceType"),
            super::super::codec::Value::String(std::string::String::from("Sequence")),
        );
        if let Some(item) = &self.id {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("id"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_id"), e);
            }
        }
        if let Some(item) = &self.meta {
            object.insert(
                std::string::String::from("meta"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.implicit_rules {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("implicitRules"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_implicitRules"), e);
            }
        }
        if let Some(item) = &self.language {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("language"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_language"), e);
            }
        }
        if let Some(item) = &self.text {
            object.insert(
                std::string::String::from("text"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if !self.contained.is_empty() {
            let mut items = Vec::with_capacity(self.contained.len());
            for item in &self.contained {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("contained"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.identifier.is_empty() {
            let mut items = Vec::with_capacity(self.identifier.len());
            for item in &self.identifier {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("identifier"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.r#type {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("type"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_type"), e);
            }
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.coordinate_system)? {
            object.insert(std::string::String::from("coordinateSystem"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.coordinate_system)? {
            object.insert(std::string::String::from("_coordinateSystem"), e);
        }
        if let Some(item) = &self.patient {
            object.insert(
                std::string::String::from("patient"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.specimen {
            object.insert(
                std::string::String::from("specimen"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.device {
            object.insert(
                std::string::String::from("device"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.performer {
            object.insert(
                std::string::String::from("performer"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.quantity {
            object.insert(
                std::string::String::from("quantity"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.reference_seq {
            object.insert(
                std::string::String::from("referenceSeq"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if !self.variant.is_empty() {
            let mut items = Vec::with_capacity(self.variant.len());
            for item in &self.variant {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("variant"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.observed_seq {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("observedSeq"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_observedSeq"), e);
            }
        }
        if !self.quality.is_empty() {
            let mut items = Vec::with_capacity(self.quality.len());
            for item in &self.quality {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("quality"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.read_coverage {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("readCoverage"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_readCoverage"), e);
            }
        }
        if !self.repository.is_empty() {
            let mut items = Vec::with_capacity(self.repository.len());
            for item in &self.repository {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("repository"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.pointer.is_empty() {
            let mut items = Vec::with_capacity(self.pointer.len());
            for item in &self.pointer {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("pointer"),
                super::super::codec::Value::Array(items),
            );
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_id_element: Option<&super::super::codec::Value> = None;
        let mut raw_meta: Option<&super::super::codec::Value> = None;
        let mut raw_implicit_rules: Option<&super::super::codec::Value> = None;
        let mut raw_implicit_rules_element: Option<&super::super::codec::Value> = None;
        let mut raw_language: Option<&super::super::codec::Value> = None;
        let mut raw_language_element: Option<&super::super::codec::Value> = None;
        let mut raw_text: Option<&super::super::codec::Value> = None;
        let mut raw_contained: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_identifier: Option<&super::super::codec::Value> = None;
        let mut raw_type: Option<&super::super::codec::Value> = None;
        let mut raw_type_element: Option<&super::super::codec::Value> = None;
        let mut raw_coordinate_system: Option<&super::super::codec::Value> = None;
        let mut raw_coordinate_system_element: Option<&super::super::codec::Value> = None;
        let mut raw_patient: Option<&super::super::codec::Value> = None;
        let mut raw_specimen: Option<&super::super::codec::Value> = None;
        let mut raw_device: Option<&super::super::codec::Value> = None;
        let mut raw_performer: Option<&super::super::codec::Value> = None;
        let mut raw_quantity: Option<&super::super::codec::Value> = None;
        let mut raw_reference_seq: Option<&super::super::codec::Value> = None;
        let mut raw_variant: Option<&super::super::codec::Value> = None;
        let mut raw_observed_seq: Option<&super::super::codec::Value> = None;
        let mut raw_observed_seq_element: Option<&super::super::codec::Value> = None;
        let mut raw_quality: Option<&super::super::codec::Value> = None;
        let mut raw_read_coverage: Option<&super::super::codec::Value> = None;
        let mut raw_read_coverage_element: Option<&super::super::codec::Value> = None;
        let mut raw_repository: Option<&super::super::codec::Value> = None;
        let mut raw_pointer: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "resourceType" => {
                    if value.as_str() != Some("Sequence") {
                        return Err(path.error(super::super::codec::DecodeErrorKind::ResourceType));
                    }
                }
                "id" => {
                    raw_id = Some(value);
                }
                "_id" => {
                    raw_id_element = Some(value);
                }
                "meta" => {
                    raw_meta = Some(value);
                }
                "implicitRules" => {
                    raw_implicit_rules = Some(value);
                }
                "_implicitRules" => {
                    raw_implicit_rules_element = Some(value);
                }
                "language" => {
                    raw_language = Some(value);
                }
                "_language" => {
                    raw_language_element = Some(value);
                }
                "text" => {
                    raw_text = Some(value);
                }
                "contained" => {
                    raw_contained = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "identifier" => {
                    raw_identifier = Some(value);
                }
                "type" => {
                    raw_type = Some(value);
                }
                "_type" => {
                    raw_type_element = Some(value);
                }
                "coordinateSystem" => {
                    raw_coordinate_system = Some(value);
                }
                "_coordinateSystem" => {
                    raw_coordinate_system_element = Some(value);
                }
                "patient" => {
                    raw_patient = Some(value);
                }
                "specimen" => {
                    raw_specimen = Some(value);
                }
                "device" => {
                    raw_device = Some(value);
                }
                "performer" => {
                    raw_performer = Some(value);
                }
                "quantity" => {
                    raw_quantity = Some(value);
                }
                "referenceSeq" => {
                    raw_reference_seq = Some(value);
                }
                "variant" => {
                    raw_variant = Some(value);
                }
                "observedSeq" => {
                    raw_observed_seq = Some(value);
                }
                "_observedSeq" => {
                    raw_observed_seq_element = Some(value);
                }
                "quality" => {
                    raw_quality = Some(value);
                }
                "readCoverage" => {
                    raw_read_coverage = Some(value);
                }
                "_readCoverage" => {
                    raw_read_coverage_element = Some(value);
                }
                "repository" => {
                    raw_repository = Some(value);
                }
                "pointer" => {
                    raw_pointer = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = match (raw_id, raw_id_element) {
            (None, None) => None,
            (value, element) => Some(path.with("id", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_meta = raw_meta
            .map(|value| {
                path.with("meta", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_implicit_rules = match (raw_implicit_rules, raw_implicit_rules_element) {
            (None, None) => None,
            (value, element) => Some(path.with("implicitRules", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_language = match (raw_language, raw_language_element) {
            (None, None) => None,
            (value, element) => Some(path.with("language", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_text = raw_text
            .map(|value| {
                path.with("text", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_contained = Vec::new();
        if let Some(raw) = raw_contained {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_contained.push(path.with_index("contained", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let mut field_identifier = Vec::new();
        if let Some(raw) = raw_identifier {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_identifier.push(path.with_index("identifier", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_type = match (raw_type, raw_type_element) {
            (None, None) => None,
            (value, element) => Some(path.with("type", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_coordinate_system = path.with("coordinateSystem", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_coordinate_system,
                raw_coordinate_system_element,
                path,
            )
        })?;
        let field_patient = raw_patient
            .map(|value| {
                path.with("patient", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_specimen = raw_specimen
            .map(|value| {
                path.with("specimen", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_device = raw_device
            .map(|value| {
                path.with("device", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_performer = raw_performer
            .map(|value| {
                path.with("performer", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_quantity = raw_quantity
            .map(|value| {
                path.with("quantity", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_reference_seq = raw_reference_seq
            .map(|value| {
                path.with("referenceSeq", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_variant = Vec::new();
        if let Some(raw) = raw_variant {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_variant.push(path.with_index("variant", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_observed_seq = match (raw_observed_seq, raw_observed_seq_element) {
            (None, None) => None,
            (value, element) => Some(path.with("observedSeq", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_quality = Vec::new();
        if let Some(raw) = raw_quality {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_quality.push(path.with_index("quality", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_read_coverage = match (raw_read_coverage, raw_read_coverage_element) {
            (None, None) => None,
            (value, element) => Some(path.with("readCoverage", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_repository = Vec::new();
        if let Some(raw) = raw_repository {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_repository.push(path.with_index("repository", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_pointer = Vec::new();
        if let Some(raw) = raw_pointer {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_pointer.push(path.with_index("pointer", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        Ok(Self {
            id: field_id,
            meta: field_meta,
            implicit_rules: field_implicit_rules,
            language: field_language,
            text: field_text,
            contained: field_contained,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            identifier: field_identifier,
            r#type: field_type,
            coordinate_system: field_coordinate_system,
            patient: field_patient,
            specimen: field_specimen,
            device: field_device,
            performer: field_performer,
            quantity: field_quantity,
            reference_seq: field_reference_seq,
            variant: field_variant,
            observed_seq: field_observed_seq,
            quality: field_quality,
            read_coverage: field_read_coverage,
            repository: field_repository,
            pointer: field_pointer,
        })
    }
}

impl serde::Serialize for Sequence {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        super::super::codec::element_entry(&mut map, "_coordinateSystem", &self.coordinate_system)?;
        if let Some(item) = &self.id {
            super::super::codec::element_entry(&mut map, "_id", item)?;
        }
        if let Some(item) = &self.implicit_rules {
            super::super::codec::element_entry(&mut map, "_implicitRules", item)?;
        }
        if let Some(item) = &self.language {
            super::super::codec::element_entry(&mut map, "_language", item)?;
        }
        if let Some(item) = &self.observed_seq {
            super::super::codec::element_entry(&mut map, "_observedSeq", item)?;
        }
        if let Some(item) = &self.read_coverage {
            super::super::codec::element_entry(&mut map, "_readCoverage", item)?;
        }
        if let Some(item) = &self.r#type {
            super::super::codec::element_entry(&mut map, "_type", item)?;
        }
        if !self.contained.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "contained", &self.contained)?;
        }
        super::super::codec::value_entry(&mut map, "coordinateSystem", &self.coordinate_system)?;
        if let Some(item) = &self.device {
            serde::ser::SerializeMap::serialize_entry(&mut map, "device", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(item) = &self.id {
            super::super::codec::value_entry(&mut map, "id", item)?;
        }
        if !self.identifier.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "identifier", &self.identifier)?;
        }
        if let Some(item) = &self.implicit_rules {
            super::super::codec::value_entry(&mut map, "implicitRules", item)?;
        }
        if let Some(item) = &self.language {
            super::super::codec::value_entry(&mut map, "language", item)?;
        }
        if let Some(item) = &self.meta {
            serde::ser::SerializeMap::serialize_entry(&mut map, "meta", item)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if let Some(item) = &self.observed_seq {
            super::super::codec::value_entry(&mut map, "observedSeq", item)?;
        }
        if let Some(item) = &self.patient {
            serde::ser::SerializeMap::serialize_entry(&mut map, "patient", item)?;
        }
        if let Some(item) = &self.performer {
            serde::ser::SerializeMap::serialize_entry(&mut map, "performer", item)?;
        }
        if !self.pointer.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "pointer", &self.pointer)?;
        }
        if !self.quality.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "quality", &self.quality)?;
        }
        if let Some(item) = &self.quantity {
            serde::ser::SerializeMap::serialize_entry(&mut map, "quantity", item)?;
        }
        if let Some(item) = &self.read_coverage {
            super::super::codec::value_entry(&mut map, "readCoverage", item)?;
        }
        if let Some(item) = &self.reference_seq {
            serde::ser::SerializeMap::serialize_entry(&mut map, "referenceSeq", item)?;
        }
        if !self.repository.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "repository", &self.repository)?;
        }
        serde::ser::SerializeMap::serialize_entry(&mut map, "resourceType", "Sequence")?;
        if let Some(item) = &self.specimen {
            serde::ser::SerializeMap::serialize_entry(&mut map, "specimen", item)?;
        }
        if let Some(item) = &self.text {
            serde::ser::SerializeMap::serialize_entry(&mut map, "text", item)?;
        }
        if let Some(item) = &self.r#type {
            super::super::codec::value_entry(&mut map, "type", item)?;
        }
        if !self.variant.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "variant", &self.variant)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for Sequence {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("Sequence");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// An set of value as quality of sequence
///
/// An experimental feature attribute that defines the quality of the feature in
/// a quantitative way, such as a phred quality score
/// (\[SO:0001686\](<http://www.sequenceontology.org/browser/current_svn/term/SO:0001686>)).
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct SequenceQuality {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional Content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. In order to make the use of extensions safe
    /// and manageable, there is a strict set of governance applied to the
    /// definition and use of extensions. Though any implementer is allowed to
    /// define an extension, there is a set of requirements that SHALL be met as
    /// part of the definition of the extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element, and that modifies the understanding of the
    /// element that contains it. Usually modifier elements provide negation or
    /// qualification. In order to make the use of extensions safe and manageable,
    /// there is a strict set of governance applied to the definition and use of
    /// extensions. Though any implementer is allowed to define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension. Applications processing a resource are required to check for
    /// modifier extensions.
    pub modifier_extension: Vec<super::extension::Extension>,
    /// indel | snp | unknown
    ///
    /// INDEL / SNP / Undefined variant.
    pub r#type: super::primitives::Code,
    /// Standard sequence for comparison
    ///
    /// Gold standard sequence used for comparing against.
    pub standard_sequence: Option<super::codeable_concept::CodeableConcept>,
    /// Start position of the sequence
    ///
    /// Start position of the sequence. If the coordinate system is either 0-based
    /// or 1-based, then start position is inclusive.
    pub start: Option<super::primitives::Integer>,
    /// End position of the sequence
    ///
    /// End position of the sequence.If the coordinate system is 0-based then end is
    /// is exclusive and does not include the last position. If the coordinate
    /// system is 1-base, then end is inclusive and includes the last position.
    pub end: Option<super::primitives::Integer>,
    /// Quality score for the comparison
    ///
    /// The score of an experimentally derived feature such as a p-value
    /// (\[SO:0001685\](<http://www.sequenceontology.org/browser/current_svn/term/SO:0001685>)).
    pub score: Option<super::quantity::Quantity>,
    /// Method to get quality
    ///
    /// Which method is used to get sequence quality.
    pub method: Option<super::codeable_concept::CodeableConcept>,
    /// True positives from the perspective of the truth data
    ///
    /// True positives, from the perspective of the truth data, i.e. the number of
    /// sites in the Truth Call Set for which there are paths through the Query Call
    /// Set that are consistent with all of the alleles at this site, and for which
    /// there is an accurate genotype call for the event.
    pub truth_t_p: Option<super::primitives::Decimal>,
    /// True positives from the perspective of the query data
    ///
    /// True positives, from the perspective of the query data, i.e. the number of
    /// sites in the Query Call Set for which there are paths through the Truth Call
    /// Set that are consistent with all of the alleles at this site, and for which
    /// there is an accurate genotype call for the event.
    pub query_t_p: Option<super::primitives::Decimal>,
    /// False negatives
    ///
    /// False negatives, i.e. the number of sites in the Truth Call Set for which
    /// there is no path through the Query Call Set that is consistent with all of
    /// the alleles at this site, or sites for which there is an inaccurate genotype
    /// call for the event. Sites with correct variant but incorrect genotype are
    /// counted here.
    pub truth_f_n: Option<super::primitives::Decimal>,
    /// False positives
    ///
    /// False positives, i.e. the number of sites in the Query Call Set for which
    /// there is no path through the Truth Call Set that is consistent with this
    /// site. Sites with correct variant but incorrect genotype are counted here.
    pub query_f_p: Option<super::primitives::Decimal>,
    /// False positives where the non-REF alleles in the Truth and Query Call Sets
    /// match
    ///
    /// The number of false positives where the non-REF alleles in the Truth and
    /// Query Call Sets match (i.e. cases where the truth is 1/1 and the query is
    /// 0/1 or similar).
    pub gt_f_p: Option<super::primitives::Decimal>,
    /// Precision of comparison
    ///
    /// QUERY.TP / (QUERY.TP + QUERY.FP).
    pub precision: Option<super::primitives::Decimal>,
    /// Recall of comparison
    ///
    /// TRUTH.TP / (TRUTH.TP + TRUTH.FN).
    pub recall: Option<super::primitives::Decimal>,
    /// F-score
    ///
    /// Harmonic mean of Recall and Precision, computed as: 2 \* precision \* recall
    /// / (precision + recall).
    pub f_score: Option<super::primitives::Decimal>,
}

impl super::super::codec::Json for SequenceQuality {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.r#type)? {
            object.insert(std::string::String::from("type"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.r#type)? {
            object.insert(std::string::String::from("_type"), e);
        }
        if let Some(item) = &self.standard_sequence {
            object.insert(
                std::string::String::from("standardSequence"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.start {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("start"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_start"), e);
            }
        }
        if let Some(item) = &self.end {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("end"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_end"), e);
            }
        }
        if let Some(item) = &self.score {
            object.insert(
                std::string::String::from("score"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.method {
            object.insert(
                std::string::String::from("method"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.truth_t_p {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("truthTP"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_truthTP"), e);
            }
        }
        if let Some(item) = &self.query_t_p {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("queryTP"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_queryTP"), e);
            }
        }
        if let Some(item) = &self.truth_f_n {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("truthFN"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_truthFN"), e);
            }
        }
        if let Some(item) = &self.query_f_p {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("queryFP"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_queryFP"), e);
            }
        }
        if let Some(item) = &self.gt_f_p {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("gtFP"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_gtFP"), e);
            }
        }
        if let Some(item) = &self.precision {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("precision"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_precision"), e);
            }
        }
        if let Some(item) = &self.recall {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("recall"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_recall"), e);
            }
        }
        if let Some(item) = &self.f_score {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("fScore"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_fScore"), e);
            }
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_type: Option<&super::super::codec::Value> = None;
        let mut raw_type_element: Option<&super::super::codec::Value> = None;
        let mut raw_standard_sequence: Option<&super::super::codec::Value> = None;
        let mut raw_start: Option<&super::super::codec::Value> = None;
        let mut raw_start_element: Option<&super::super::codec::Value> = None;
        let mut raw_end: Option<&super::super::codec::Value> = None;
        let mut raw_end_element: Option<&super::super::codec::Value> = None;
        let mut raw_score: Option<&super::super::codec::Value> = None;
        let mut raw_method: Option<&super::super::codec::Value> = None;
        let mut raw_truth_t_p: Option<&super::super::codec::Value> = None;
        let mut raw_truth_t_p_element: Option<&super::super::codec::Value> = None;
        let mut raw_query_t_p: Option<&super::super::codec::Value> = None;
        let mut raw_query_t_p_element: Option<&super::super::codec::Value> = None;
        let mut raw_truth_f_n: Option<&super::super::codec::Value> = None;
        let mut raw_truth_f_n_element: Option<&super::super::codec::Value> = None;
        let mut raw_query_f_p: Option<&super::super::codec::Value> = None;
        let mut raw_query_f_p_element: Option<&super::super::codec::Value> = None;
        let mut raw_gt_f_p: Option<&super::super::codec::Value> = None;
        let mut raw_gt_f_p_element: Option<&super::super::codec::Value> = None;
        let mut raw_precision: Option<&super::super::codec::Value> = None;
        let mut raw_precision_element: Option<&super::super::codec::Value> = None;
        let mut raw_recall: Option<&super::super::codec::Value> = None;
        let mut raw_recall_element: Option<&super::super::codec::Value> = None;
        let mut raw_f_score: Option<&super::super::codec::Value> = None;
        let mut raw_f_score_element: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "type" => {
                    raw_type = Some(value);
                }
                "_type" => {
                    raw_type_element = Some(value);
                }
                "standardSequence" => {
                    raw_standard_sequence = Some(value);
                }
                "start" => {
                    raw_start = Some(value);
                }
                "_start" => {
                    raw_start_element = Some(value);
                }
                "end" => {
                    raw_end = Some(value);
                }
                "_end" => {
                    raw_end_element = Some(value);
                }
                "score" => {
                    raw_score = Some(value);
                }
                "method" => {
                    raw_method = Some(value);
                }
                "truthTP" => {
                    raw_truth_t_p = Some(value);
                }
                "_truthTP" => {
                    raw_truth_t_p_element = Some(value);
                }
                "queryTP" => {
                    raw_query_t_p = Some(value);
                }
                "_queryTP" => {
                    raw_query_t_p_element = Some(value);
                }
                "truthFN" => {
                    raw_truth_f_n = Some(value);
                }
                "_truthFN" => {
                    raw_truth_f_n_element = Some(value);
                }
                "queryFP" => {
                    raw_query_f_p = Some(value);
                }
                "_queryFP" => {
                    raw_query_f_p_element = Some(value);
                }
                "gtFP" => {
                    raw_gt_f_p = Some(value);
                }
                "_gtFP" => {
                    raw_gt_f_p_element = Some(value);
                }
                "precision" => {
                    raw_precision = Some(value);
                }
                "_precision" => {
                    raw_precision_element = Some(value);
                }
                "recall" => {
                    raw_recall = Some(value);
                }
                "_recall" => {
                    raw_recall_element = Some(value);
                }
                "fScore" => {
                    raw_f_score = Some(value);
                }
                "_fScore" => {
                    raw_f_score_element = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_type = path.with("type", |path| {
            super::super::codec::Primitive::from_json_parts(raw_type, raw_type_element, path)
        })?;
        let field_standard_sequence = raw_standard_sequence
            .map(|value| {
                path.with("standardSequence", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_start = match (raw_start, raw_start_element) {
            (None, None) => None,
            (value, element) => Some(path.with("start", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_end = match (raw_end, raw_end_element) {
            (None, None) => None,
            (value, element) => Some(path.with("end", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_score = raw_score
            .map(|value| {
                path.with("score", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_method = raw_method
            .map(|value| {
                path.with("method", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_truth_t_p = match (raw_truth_t_p, raw_truth_t_p_element) {
            (None, None) => None,
            (value, element) => Some(path.with("truthTP", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_query_t_p = match (raw_query_t_p, raw_query_t_p_element) {
            (None, None) => None,
            (value, element) => Some(path.with("queryTP", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_truth_f_n = match (raw_truth_f_n, raw_truth_f_n_element) {
            (None, None) => None,
            (value, element) => Some(path.with("truthFN", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_query_f_p = match (raw_query_f_p, raw_query_f_p_element) {
            (None, None) => None,
            (value, element) => Some(path.with("queryFP", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_gt_f_p = match (raw_gt_f_p, raw_gt_f_p_element) {
            (None, None) => None,
            (value, element) => Some(path.with("gtFP", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_precision = match (raw_precision, raw_precision_element) {
            (None, None) => None,
            (value, element) => Some(path.with("precision", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_recall = match (raw_recall, raw_recall_element) {
            (None, None) => None,
            (value, element) => Some(path.with("recall", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_f_score = match (raw_f_score, raw_f_score_element) {
            (None, None) => None,
            (value, element) => Some(path.with("fScore", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            r#type: field_type,
            standard_sequence: field_standard_sequence,
            start: field_start,
            end: field_end,
            score: field_score,
            method: field_method,
            truth_t_p: field_truth_t_p,
            query_t_p: field_query_t_p,
            truth_f_n: field_truth_f_n,
            query_f_p: field_query_f_p,
            gt_f_p: field_gt_f_p,
            precision: field_precision,
            recall: field_recall,
            f_score: field_f_score,
        })
    }
}

impl serde::Serialize for SequenceQuality {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if let Some(item) = &self.end {
            super::super::codec::element_entry(&mut map, "_end", item)?;
        }
        if let Some(item) = &self.f_score {
            super::super::codec::element_entry(&mut map, "_fScore", item)?;
        }
        if let Some(item) = &self.gt_f_p {
            super::super::codec::element_entry(&mut map, "_gtFP", item)?;
        }
        if let Some(item) = &self.precision {
            super::super::codec::element_entry(&mut map, "_precision", item)?;
        }
        if let Some(item) = &self.query_f_p {
            super::super::codec::element_entry(&mut map, "_queryFP", item)?;
        }
        if let Some(item) = &self.query_t_p {
            super::super::codec::element_entry(&mut map, "_queryTP", item)?;
        }
        if let Some(item) = &self.recall {
            super::super::codec::element_entry(&mut map, "_recall", item)?;
        }
        if let Some(item) = &self.start {
            super::super::codec::element_entry(&mut map, "_start", item)?;
        }
        if let Some(item) = &self.truth_f_n {
            super::super::codec::element_entry(&mut map, "_truthFN", item)?;
        }
        if let Some(item) = &self.truth_t_p {
            super::super::codec::element_entry(&mut map, "_truthTP", item)?;
        }
        super::super::codec::element_entry(&mut map, "_type", &self.r#type)?;
        if let Some(item) = &self.end {
            super::super::codec::value_entry(&mut map, "end", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(item) = &self.f_score {
            super::super::codec::value_entry(&mut map, "fScore", item)?;
        }
        if let Some(item) = &self.gt_f_p {
            super::super::codec::value_entry(&mut map, "gtFP", item)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if let Some(item) = &self.method {
            serde::ser::SerializeMap::serialize_entry(&mut map, "method", item)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if let Some(item) = &self.precision {
            super::super::codec::value_entry(&mut map, "precision", item)?;
        }
        if let Some(item) = &self.query_f_p {
            super::super::codec::value_entry(&mut map, "queryFP", item)?;
        }
        if let Some(item) = &self.query_t_p {
            super::super::codec::value_entry(&mut map, "queryTP", item)?;
        }
        if let Some(item) = &self.recall {
            super::super::codec::value_entry(&mut map, "recall", item)?;
        }
        if let Some(item) = &self.score {
            serde::ser::SerializeMap::serialize_entry(&mut map, "score", item)?;
        }
        if let Some(item) = &self.standard_sequence {
            serde::ser::SerializeMap::serialize_entry(&mut map, "standardSequence", item)?;
        }
        if let Some(item) = &self.start {
            super::super::codec::value_entry(&mut map, "start", item)?;
        }
        if let Some(item) = &self.truth_f_n {
            super::super::codec::value_entry(&mut map, "truthFN", item)?;
        }
        if let Some(item) = &self.truth_t_p {
            super::super::codec::value_entry(&mut map, "truthTP", item)?;
        }
        super::super::codec::value_entry(&mut map, "type", &self.r#type)?;
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for SequenceQuality {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("SequenceQuality");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// A sequence used as reference
///
/// A sequence that is used as a reference to describe variants that are present
/// in a sequence analyzed.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct SequenceReferenceSeq {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional Content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. In order to make the use of extensions safe
    /// and manageable, there is a strict set of governance applied to the
    /// definition and use of extensions. Though any implementer is allowed to
    /// define an extension, there is a set of requirements that SHALL be met as
    /// part of the definition of the extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element, and that modifies the understanding of the
    /// element that contains it. Usually modifier elements provide negation or
    /// qualification. In order to make the use of extensions safe and manageable,
    /// there is a strict set of governance applied to the definition and use of
    /// extensions. Though any implementer is allowed to define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension. Applications processing a resource are required to check for
    /// modifier extensions.
    pub modifier_extension: Vec<super::extension::Extension>,
    /// Chromosome containing genetic finding
    ///
    /// Structural unit composed of a nucleic acid molecule which controls its own
    /// replication through the interaction of specific proteins at one or more
    /// origins of replication
    /// (\[SO:0000340\](<http://www.sequenceontology.org/browser/current_svn/term/SO:0000340>)).
    pub chromosome: Option<super::codeable_concept::CodeableConcept>,
    /// The Genome Build used for reference, following GRCh build versions e.g.
    /// 'GRCh 37'
    ///
    /// The Genome Build used for reference, following GRCh build versions e.g.
    /// 'GRCh 37'. Version number must be included if a versioned release of a
    /// primary build was used.
    pub genome_build: Option<super::primitives::String>,
    /// Reference identifier
    ///
    /// Reference identifier of reference sequence submitted to NCBI. It must match
    /// the type in the Sequence.type field. For example, the prefix, “NG\_”
    /// identifies reference sequence for genes, “NM\_” for messenger RNA
    /// transcripts, and “NP\_” for amino acid sequences.
    pub reference_seq_id: Option<super::codeable_concept::CodeableConcept>,
    /// A Pointer to another Sequence entity as reference sequence.
    pub reference_seq_pointer: Option<super::reference::Reference>,
    /// A string to represent reference sequence
    ///
    /// A string like "ACGT".
    pub reference_seq_string: Option<super::primitives::String>,
    /// Directionality of DNA ( +1/-1)
    ///
    /// Directionality of DNA sequence. Available values are "1" for the plus strand
    /// (5' to 3')/Watson/Sense/positive and "-1" for the minus strand(3' to
    /// 5')/Crick/Antisense/negative.
    pub strand: Option<super::primitives::Integer>,
    /// Start position of the window on the reference sequence
    ///
    /// Start position of the window on the reference sequence. If the coordinate
    /// system is either 0-based or 1-based, then start position is inclusive.
    pub window_start: super::primitives::Integer,
    /// End position of the window on the reference sequence
    ///
    /// End position of the window on the reference sequence. If the coordinate
    /// system is 0-based then end is is exclusive and does not include the last
    /// position. If the coordinate system is 1-base, then end is inclusive and
    /// includes the last position.
    pub window_end: super::primitives::Integer,
}

impl super::super::codec::Json for SequenceReferenceSeq {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.chromosome {
            object.insert(
                std::string::String::from("chromosome"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.genome_build {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("genomeBuild"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_genomeBuild"), e);
            }
        }
        if let Some(item) = &self.reference_seq_id {
            object.insert(
                std::string::String::from("referenceSeqId"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.reference_seq_pointer {
            object.insert(
                std::string::String::from("referenceSeqPointer"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.reference_seq_string {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("referenceSeqString"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_referenceSeqString"), e);
            }
        }
        if let Some(item) = &self.strand {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("strand"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_strand"), e);
            }
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.window_start)? {
            object.insert(std::string::String::from("windowStart"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.window_start)? {
            object.insert(std::string::String::from("_windowStart"), e);
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.window_end)? {
            object.insert(std::string::String::from("windowEnd"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.window_end)? {
            object.insert(std::string::String::from("_windowEnd"), e);
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_chromosome: Option<&super::super::codec::Value> = None;
        let mut raw_genome_build: Option<&super::super::codec::Value> = None;
        let mut raw_genome_build_element: Option<&super::super::codec::Value> = None;
        let mut raw_reference_seq_id: Option<&super::super::codec::Value> = None;
        let mut raw_reference_seq_pointer: Option<&super::super::codec::Value> = None;
        let mut raw_reference_seq_string: Option<&super::super::codec::Value> = None;
        let mut raw_reference_seq_string_element: Option<&super::super::codec::Value> = None;
        let mut raw_strand: Option<&super::super::codec::Value> = None;
        let mut raw_strand_element: Option<&super::super::codec::Value> = None;
        let mut raw_window_start: Option<&super::super::codec::Value> = None;
        let mut raw_window_start_element: Option<&super::super::codec::Value> = None;
        let mut raw_window_end: Option<&super::super::codec::Value> = None;
        let mut raw_window_end_element: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "chromosome" => {
                    raw_chromosome = Some(value);
                }
                "genomeBuild" => {
                    raw_genome_build = Some(value);
                }
                "_genomeBuild" => {
                    raw_genome_build_element = Some(value);
                }
                "referenceSeqId" => {
                    raw_reference_seq_id = Some(value);
                }
                "referenceSeqPointer" => {
                    raw_reference_seq_pointer = Some(value);
                }
                "referenceSeqString" => {
                    raw_reference_seq_string = Some(value);
                }
                "_referenceSeqString" => {
                    raw_reference_seq_string_element = Some(value);
                }
                "strand" => {
                    raw_strand = Some(value);
                }
                "_strand" => {
                    raw_strand_element = Some(value);
                }
                "windowStart" => {
                    raw_window_start = Some(value);
                }
                "_windowStart" => {
                    raw_window_start_element = Some(value);
                }
                "windowEnd" => {
                    raw_window_end = Some(value);
                }
                "_windowEnd" => {
                    raw_window_end_element = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_chromosome = raw_chromosome
            .map(|value| {
                path.with("chromosome", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_genome_build = match (raw_genome_build, raw_genome_build_element) {
            (None, None) => None,
            (value, element) => Some(path.with("genomeBuild", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_reference_seq_id = raw_reference_seq_id
            .map(|value| {
                path.with("referenceSeqId", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_reference_seq_pointer = raw_reference_seq_pointer
            .map(|value| {
                path.with("referenceSeqPointer", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_reference_seq_string =
            match (raw_reference_seq_string, raw_reference_seq_string_element) {
                (None, None) => None,
                (value, element) => Some(path.with("referenceSeqString", |path| {
                    super::super::codec::Primitive::from_json_parts(value, element, path)
                })?),
            };
        let field_strand = match (raw_strand, raw_strand_element) {
            (None, None) => None,
            (value, element) => Some(path.with("strand", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_window_start = path.with("windowStart", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_window_start,
                raw_window_start_element,
                path,
            )
        })?;
        let field_window_end = path.with("windowEnd", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_window_end,
                raw_window_end_element,
                path,
            )
        })?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            chromosome: field_chromosome,
            genome_build: field_genome_build,
            reference_seq_id: field_reference_seq_id,
            reference_seq_pointer: field_reference_seq_pointer,
            reference_seq_string: field_reference_seq_string,
            strand: field_strand,
            window_start: field_window_start,
            window_end: field_window_end,
        })
    }
}

impl serde::Serialize for SequenceReferenceSeq {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if let Some(item) = &self.genome_build {
            super::super::codec::element_entry(&mut map, "_genomeBuild", item)?;
        }
        if let Some(item) = &self.reference_seq_string {
            super::super::codec::element_entry(&mut map, "_referenceSeqString", item)?;
        }
        if let Some(item) = &self.strand {
            super::super::codec::element_entry(&mut map, "_strand", item)?;
        }
        super::super::codec::element_entry(&mut map, "_windowEnd", &self.window_end)?;
        super::super::codec::element_entry(&mut map, "_windowStart", &self.window_start)?;
        if let Some(item) = &self.chromosome {
            serde::ser::SerializeMap::serialize_entry(&mut map, "chromosome", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(item) = &self.genome_build {
            super::super::codec::value_entry(&mut map, "genomeBuild", item)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if let Some(item) = &self.reference_seq_id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "referenceSeqId", item)?;
        }
        if let Some(item) = &self.reference_seq_pointer {
            serde::ser::SerializeMap::serialize_entry(&mut map, "referenceSeqPointer", item)?;
        }
        if let Some(item) = &self.reference_seq_string {
            super::super::codec::value_entry(&mut map, "referenceSeqString", item)?;
        }
        if let Some(item) = &self.strand {
            super::super::codec::value_entry(&mut map, "strand", item)?;
        }
        super::super::codec::value_entry(&mut map, "windowEnd", &self.window_end)?;
        super::super::codec::value_entry(&mut map, "windowStart", &self.window_start)?;
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for SequenceReferenceSeq {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("SequenceReferenceSeq");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// External repository which contains detailed report related with observedSeq
/// in this resource
///
/// Configurations of the external repository. The repository shall store
/// target's observedSeq or records related with target's observedSeq.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct SequenceRepository {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional Content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. In order to make the use of extensions safe
    /// and manageable, there is a strict set of governance applied to the
    /// definition and use of extensions. Though any implementer is allowed to
    /// define an extension, there is a set of requirements that SHALL be met as
    /// part of the definition of the extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element, and that modifies the understanding of the
    /// element that contains it. Usually modifier elements provide negation or
    /// qualification. In order to make the use of extensions safe and manageable,
    /// there is a strict set of governance applied to the definition and use of
    /// extensions. Though any implementer is allowed to define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension. Applications processing a resource are required to check for
    /// modifier extensions.
    pub modifier_extension: Vec<super::extension::Extension>,
    /// directlink | openapi | login | oauth | other
    ///
    /// Click and see / RESTful API / Need login to see / RESTful API with
    /// authentication / Other ways to see resource.
    pub r#type: super::primitives::Code,
    /// URI of the repository
    ///
    /// URI of an external repository which contains further details about the
    /// genetics data.
    pub url: Option<super::primitives::Uri>,
    /// Repository's name
    ///
    /// URI of an external repository which contains further details about the
    /// genetics data.
    pub name: Option<super::primitives::String>,
    /// Id of the dataset that used to call for dataset in repository
    ///
    /// Id of the variant in this external repository. The server will understand
    /// how to use this id to call for more info about datasets in external
    /// repository.
    pub dataset_id: Option<super::primitives::String>,
    /// Id of the variantset that used to call for variantset in repository
    ///
    /// Id of the variantset in this external repository. The server will understand
    /// how to use this id to call for more info about variantsets in external
    /// repository.
    pub variantset_id: Option<super::primitives::String>,
    /// Id of the read
    ///
    /// Id of the read in this external repository.
    pub readset_id: Option<super::primitives::String>,
}

impl super::super::codec::Json for SequenceRepository {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.r#type)? {
            object.insert(std::string::String::from("type"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.r#type)? {
            object.insert(std::string::String::from("_type"), e);
        }
        if let Some(item) = &self.url {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("url"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_url"), e);
            }
        }
        if let Some(item) = &self.name {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("name"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_name"), e);
            }
        }
        if let Some(item) = &self.dataset_id {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("datasetId"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_datasetId"), e);
            }
        }
        if let Some(item) = &self.variantset_id {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("variantsetId"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_variantsetId"), e);
            }
        }
        if let Some(item) = &self.readset_id {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("readsetId"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_readsetId"), e);
            }
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_type: Option<&super::super::codec::Value> = None;
        let mut raw_type_element: Option<&super::super::codec::Value> = None;
        let mut raw_url: Option<&super::super::codec::Value> = None;
        let mut raw_url_element: Option<&super::super::codec::Value> = None;
        let mut raw_name: Option<&super::super::codec::Value> = None;
        let mut raw_name_element: Option<&super::super::codec::Value> = None;
        let mut raw_dataset_id: Option<&super::super::codec::Value> = None;
        let mut raw_dataset_id_element: Option<&super::super::codec::Value> = None;
        let mut raw_variantset_id: Option<&super::super::codec::Value> = None;
        let mut raw_variantset_id_element: Option<&super::super::codec::Value> = None;
        let mut raw_readset_id: Option<&super::super::codec::Value> = None;
        let mut raw_readset_id_element: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "type" => {
                    raw_type = Some(value);
                }
                "_type" => {
                    raw_type_element = Some(value);
                }
                "url" => {
                    raw_url = Some(value);
                }
                "_url" => {
                    raw_url_element = Some(value);
                }
                "name" => {
                    raw_name = Some(value);
                }
                "_name" => {
                    raw_name_element = Some(value);
                }
                "datasetId" => {
                    raw_dataset_id = Some(value);
                }
                "_datasetId" => {
                    raw_dataset_id_element = Some(value);
                }
                "variantsetId" => {
                    raw_variantset_id = Some(value);
                }
                "_variantsetId" => {
                    raw_variantset_id_element = Some(value);
                }
                "readsetId" => {
                    raw_readset_id = Some(value);
                }
                "_readsetId" => {
                    raw_readset_id_element = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_type = path.with("type", |path| {
            super::super::codec::Primitive::from_json_parts(raw_type, raw_type_element, path)
        })?;
        let field_url = match (raw_url, raw_url_element) {
            (None, None) => None,
            (value, element) => Some(path.with("url", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_name = match (raw_name, raw_name_element) {
            (None, None) => None,
            (value, element) => Some(path.with("name", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_dataset_id = match (raw_dataset_id, raw_dataset_id_element) {
            (None, None) => None,
            (value, element) => Some(path.with("datasetId", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_variantset_id = match (raw_variantset_id, raw_variantset_id_element) {
            (None, None) => None,
            (value, element) => Some(path.with("variantsetId", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_readset_id = match (raw_readset_id, raw_readset_id_element) {
            (None, None) => None,
            (value, element) => Some(path.with("readsetId", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            r#type: field_type,
            url: field_url,
            name: field_name,
            dataset_id: field_dataset_id,
            variantset_id: field_variantset_id,
            readset_id: field_readset_id,
        })
    }
}

impl serde::Serialize for SequenceRepository {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if let Some(item) = &self.dataset_id {
            super::super::codec::element_entry(&mut map, "_datasetId", item)?;
        }
        if let Some(item) = &self.name {
            super::super::codec::element_entry(&mut map, "_name", item)?;
        }
        if let Some(item) = &self.readset_id {
            super::super::codec::element_entry(&mut map, "_readsetId", item)?;
        }
        super::super::codec::element_entry(&mut map, "_type", &self.r#type)?;
        if let Some(item) = &self.url {
            super::super::codec::element_entry(&mut map, "_url", item)?;
        }
        if let Some(item) = &self.variantset_id {
            super::super::codec::element_entry(&mut map, "_variantsetId", item)?;
        }
        if let Some(item) = &self.dataset_id {
            super::super::codec::value_entry(&mut map, "datasetId", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if let Some(item) = &self.name {
            super::super::codec::value_entry(&mut map, "name", item)?;
        }
        if let Some(item) = &self.readset_id {
            super::super::codec::value_entry(&mut map, "readsetId", item)?;
        }
        super::super::codec::value_entry(&mut map, "type", &self.r#type)?;
        if let Some(item) = &self.url {
            super::super::codec::value_entry(&mut map, "url", item)?;
        }
        if let Some(item) = &self.variantset_id {
            super::super::codec::value_entry(&mut map, "variantsetId", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for SequenceRepository {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("SequenceRepository");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// Variant in sequence
///
/// The definition of variant here originates from Sequence ontology
/// (\[variant\_of\](<http://www.sequenceontology.org/browser/current_svn/term/variant_of>)).
/// This element can represent amino acid or nucleic sequence change(including
/// insertion,deletion,SNP,etc.) It can represent some complex mutation or
/// segment variation with the assist of CIGAR string.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct SequenceVariant {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional Content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. In order to make the use of extensions safe
    /// and manageable, there is a strict set of governance applied to the
    /// definition and use of extensions. Though any implementer is allowed to
    /// define an extension, there is a set of requirements that SHALL be met as
    /// part of the definition of the extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element, and that modifies the understanding of the
    /// element that contains it. Usually modifier elements provide negation or
    /// qualification. In order to make the use of extensions safe and manageable,
    /// there is a strict set of governance applied to the definition and use of
    /// extensions. Though any implementer is allowed to define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension. Applications processing a resource are required to check for
    /// modifier extensions.
    pub modifier_extension: Vec<super::extension::Extension>,
    /// Start position of the variant on the reference sequence
    ///
    /// Start position of the variant on the reference sequence.If the coordinate
    /// system is either 0-based or 1-based, then start position is inclusive.
    pub start: Option<super::primitives::Integer>,
    /// End position of the variant on the reference sequence
    ///
    /// End position of the variant on the reference sequence.If the coordinate
    /// system is 0-based then end is is exclusive and does not include the last
    /// position. If the coordinate system is 1-base, then end is inclusive and
    /// includes the last position.
    pub end: Option<super::primitives::Integer>,
    /// Allele that was observed
    ///
    /// An allele is one of a set of coexisting sequence variants of a gene
    /// (\[SO:0001023\](<http://www.sequenceontology.org/browser/current_svn/term/SO:0001023>)).
    /// Nucleotide(s)/amino acids from start position of sequence to stop position
    /// of sequence on the positive (+) strand of the observed sequence. When the
    /// sequence type is DNA, it should be the sequence on the positive (+) strand.
    /// This will lay in the range between variant.start and variant.end.
    pub observed_allele: Option<super::primitives::String>,
    /// Allele in the reference sequence
    ///
    /// An allele is one of a set of coexisting sequence variants of a gene
    /// (\[SO:0001023\](<http://www.sequenceontology.org/browser/current_svn/term/SO:0001023>)).
    /// Nucleotide(s)/amino acids from start position of sequence to stop position
    /// of sequence on the positive (+) strand of the reference sequence. When the
    /// sequence type is DNA, it should be the sequence on the positive (+) strand.
    /// This will lay in the range between variant.start and variant.end.
    pub reference_allele: Option<super::primitives::String>,
    /// Extended CIGAR string for aligning the sequence with reference bases
    ///
    /// Extended CIGAR string for aligning the sequence with reference bases. See
    /// detailed documentation
    /// \[here\](<http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm>).
    pub cigar: Option<super::primitives::String>,
    /// Pointer to observed variant information
    ///
    /// A pointer to an Observation containing variant information.
    pub variant_pointer: Option<super::reference::Reference>,
}

impl super::super::codec::Json for SequenceVariant {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.start {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("start"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_start"), e);
            }
        }
        if let Some(item) = &self.end {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("end"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_end"), e);
            }
        }
        if let Some(item) = &self.observed_allele {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("observedAllele"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_observedAllele"), e);
            }
        }
        if let Some(item) = &self.reference_allele {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("referenceAllele"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_referenceAllele"), e);
            }
        }
        if let Some(item) = &self.cigar {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("cigar"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_cigar"), e);
            }
        }
        if let Some(item) = &self.variant_pointer {
            object.insert(
                std::string::String::from("variantPointer"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_start: Option<&super::super::codec::Value> = None;
        let mut raw_start_element: Option<&super::super::codec::Value> = None;
        let mut raw_end: Option<&super::super::codec::Value> = None;
        let mut raw_end_element: Option<&super::super::codec::Value> = None;
        let mut raw_observed_allele: Option<&super::super::codec::Value> = None;
        let mut raw_observed_allele_element: Option<&super::super::codec::Value> = None;
        let mut raw_reference_allele: Option<&super::super::codec::Value> = None;
        let mut raw_reference_allele_element: Option<&super::super::codec::Value> = None;
        let mut raw_cigar: Option<&super::super::codec::Value> = None;
        let mut raw_cigar_element: Option<&super::super::codec::Value> = None;
        let mut raw_variant_pointer: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "start" => {
                    raw_start = Some(value);
                }
                "_start" => {
                    raw_start_element = Some(value);
                }
                "end" => {
                    raw_end = Some(value);
                }
                "_end" => {
                    raw_end_element = Some(value);
                }
                "observedAllele" => {
                    raw_observed_allele = Some(value);
                }
                "_observedAllele" => {
                    raw_observed_allele_element = Some(value);
                }
                "referenceAllele" => {
                    raw_reference_allele = Some(value);
                }
                "_referenceAllele" => {
                    raw_reference_allele_element = Some(value);
                }
                "cigar" => {
                    raw_cigar = Some(value);
                }
                "_cigar" => {
                    raw_cigar_element = Some(value);
                }
                "variantPointer" => {
                    raw_variant_pointer = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_start = match (raw_start, raw_start_element) {
            (None, None) => None,
            (value, element) => Some(path.with("start", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_end = match (raw_end, raw_end_element) {
            (None, None) => None,
            (value, element) => Some(path.with("end", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_observed_allele = match (raw_observed_allele, raw_observed_allele_element) {
            (None, None) => None,
            (value, element) => Some(path.with("observedAllele", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_reference_allele = match (raw_reference_allele, raw_reference_allele_element) {
            (None, None) => None,
            (value, element) => Some(path.with("referenceAllele", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_cigar = match (raw_cigar, raw_cigar_element) {
            (None, None) => None,
            (value, element) => Some(path.with("cigar", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_variant_pointer = raw_variant_pointer
            .map(|value| {
                path.with("variantPointer", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            start: field_start,
            end: field_end,
            observed_allele: field_observed_allele,
            reference_allele: field_reference_allele,
            cigar: field_cigar,
            variant_pointer: field_variant_pointer,
        })
    }
}

impl serde::Serialize for SequenceVariant {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if let Some(item) = &self.cigar {
            super::super::codec::element_entry(&mut map, "_cigar", item)?;
        }
        if let Some(item) = &self.end {
            super::super::codec::element_entry(&mut map, "_end", item)?;
        }
        if let Some(item) = &self.observed_allele {
            super::super::codec::element_entry(&mut map, "_observedAllele", item)?;
        }
        if let Some(item) = &self.reference_allele {
            super::super::codec::element_entry(&mut map, "_referenceAllele", item)?;
        }
        if let Some(item) = &self.start {
            super::super::codec::element_entry(&mut map, "_start", item)?;
        }
        if let Some(item) = &self.cigar {
            super::super::codec::value_entry(&mut map, "cigar", item)?;
        }
        if let Some(item) = &self.end {
            super::super::codec::value_entry(&mut map, "end", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if let Some(item) = &self.observed_allele {
            super::super::codec::value_entry(&mut map, "observedAllele", item)?;
        }
        if let Some(item) = &self.reference_allele {
            super::super::codec::value_entry(&mut map, "referenceAllele", item)?;
        }
        if let Some(item) = &self.start {
            super::super::codec::value_entry(&mut map, "start", item)?;
        }
        if let Some(item) = &self.variant_pointer {
            serde::ser::SerializeMap::serialize_entry(&mut map, "variantPointer", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for SequenceVariant {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("SequenceVariant");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}