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
//! A Map of relationships between 2 structures that can be used to transform data

/// A Map of relationships between 2 structures that can be used to transform
/// data.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct StructureMap {
    /// 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>,
    /// Logical URI to reference this structure map (globally unique)
    ///
    /// An absolute URI that is used to identify this structure map when it is
    /// referenced in a specification, model, design or an instance. This SHALL be a
    /// URL, SHOULD be globally unique, and SHOULD be an address at which this
    /// structure map is (or will be) published. The URL SHOULD include the major
    /// version of the structure map. For more information see \[Technical and
    /// Business Versions\](resource.html\#versions).
    pub url: super::primitives::Uri,
    /// Additional identifier for the structure map
    ///
    /// A formal identifier that is used to identify this structure map when it is
    /// represented in other formats, or referenced in a specification, model,
    /// design or an instance.
    pub identifier: Vec<super::identifier::Identifier>,
    /// Business version of the structure map
    ///
    /// The identifier that is used to identify this version of the structure map
    /// when it is referenced in a specification, model, design or instance. This is
    /// an arbitrary value managed by the structure map author and is not expected
    /// to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd)
    /// if a managed version is not available. There is also no expectation that
    /// versions can be placed in a lexicographical sequence.
    pub version: Option<super::primitives::String>,
    /// Name for this structure map (computer friendly)
    ///
    /// A natural language name identifying the structure map. This name should be
    /// usable as an identifier for the module by machine processing applications
    /// such as code generation.
    pub name: super::primitives::String,
    /// Name for this structure map (human friendly)
    ///
    /// A short, descriptive, user-friendly title for the structure map.
    pub title: Option<super::primitives::String>,
    /// draft | active | retired | unknown
    ///
    /// The status of this structure map. Enables tracking the life-cycle of the
    /// content.
    pub status: super::primitives::Code,
    /// For testing purposes, not real usage
    ///
    /// A boolean value to indicate that this structure map is authored for testing
    /// purposes (or education/evaluation/marketing), and is not intended to be used
    /// for genuine usage.
    pub experimental: Option<super::primitives::Boolean>,
    /// Date this was last changed
    ///
    /// The date (and optionally time) when the structure map was published. The
    /// date must change if and when the business version changes and it must change
    /// if the status code changes. In addition, it should change when the
    /// substantive content of the structure map changes.
    pub date: Option<super::primitives::DateTime>,
    /// Name of the publisher (organization or individual)
    ///
    /// The name of the individual or organization that published the structure map.
    pub publisher: Option<super::primitives::String>,
    /// Contact details for the publisher
    ///
    /// Contact details to assist a user in finding and communicating with the
    /// publisher.
    pub contact: Vec<super::contact_detail::ContactDetail>,
    /// Natural language description of the structure map
    ///
    /// A free text natural language description of the structure map from a
    /// consumer's perspective.
    pub description: Option<super::primitives::Markdown>,
    /// Context the content is intended to support
    ///
    /// The content was developed with a focus and intent of supporting the contexts
    /// that are listed. These terms may be used to assist with indexing and
    /// searching for appropriate structure map instances.
    pub use_context: Vec<super::usage_context::UsageContext>,
    /// Intended jurisdiction for structure map (if applicable)
    ///
    /// A legal or geographic region in which the structure map is intended to be
    /// used.
    pub jurisdiction: Vec<super::codeable_concept::CodeableConcept>,
    /// Why this structure map is defined
    ///
    /// Explaination of why this structure map is needed and why it has been
    /// designed as it has.
    pub purpose: Option<super::primitives::Markdown>,
    /// Use and/or publishing restrictions
    ///
    /// A copyright statement relating to the structure map and/or its contents.
    /// Copyright statements are generally legal restrictions on the use and
    /// publishing of the structure map.
    pub copyright: Option<super::primitives::Markdown>,
    /// Structure Definition used by this map
    ///
    /// A structure definition used by this map. The structure definition may
    /// describe instances that are converted, or the instances that are produced.
    pub structure: Vec<StructureMapStructure>,
    /// Other maps used by this map (canonical URLs).
    pub import: Vec<super::primitives::Uri>,
    /// Named sections for reader convenience
    ///
    /// Organizes the mapping into managable chunks for human review/ease of
    /// maintenance.
    pub group: Vec<StructureMapGroup>,
}

impl super::super::codec::Json for StructureMap {
    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("StructureMap")),
        );
        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 let Some(v) = super::super::codec::Primitive::value_json(&self.url)? {
            object.insert(std::string::String::from("url"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.url)? {
            object.insert(std::string::String::from("_url"), e);
        }
        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.version {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("version"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_version"), e);
            }
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.name)? {
            object.insert(std::string::String::from("name"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.name)? {
            object.insert(std::string::String::from("_name"), e);
        }
        if let Some(item) = &self.title {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("title"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_title"), e);
            }
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.status)? {
            object.insert(std::string::String::from("status"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.status)? {
            object.insert(std::string::String::from("_status"), e);
        }
        if let Some(item) = &self.experimental {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("experimental"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_experimental"), e);
            }
        }
        if let Some(item) = &self.date {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("date"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_date"), e);
            }
        }
        if let Some(item) = &self.publisher {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("publisher"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_publisher"), e);
            }
        }
        if !self.contact.is_empty() {
            let mut items = Vec::with_capacity(self.contact.len());
            for item in &self.contact {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("contact"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.description {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("description"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_description"), e);
            }
        }
        if !self.use_context.is_empty() {
            let mut items = Vec::with_capacity(self.use_context.len());
            for item in &self.use_context {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("useContext"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.jurisdiction.is_empty() {
            let mut items = Vec::with_capacity(self.jurisdiction.len());
            for item in &self.jurisdiction {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("jurisdiction"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.purpose {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("purpose"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_purpose"), e);
            }
        }
        if let Some(item) = &self.copyright {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("copyright"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_copyright"), e);
            }
        }
        if !self.structure.is_empty() {
            let mut items = Vec::with_capacity(self.structure.len());
            for item in &self.structure {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("structure"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.import.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.import)?;
            object.insert(std::string::String::from("import"), values);
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_import"), elements);
            }
        }
        if !self.group.is_empty() {
            let mut items = Vec::with_capacity(self.group.len());
            for item in &self.group {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("group"),
                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_url: Option<&super::super::codec::Value> = None;
        let mut raw_url_element: Option<&super::super::codec::Value> = None;
        let mut raw_identifier: Option<&super::super::codec::Value> = None;
        let mut raw_version: Option<&super::super::codec::Value> = None;
        let mut raw_version_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_title: Option<&super::super::codec::Value> = None;
        let mut raw_title_element: Option<&super::super::codec::Value> = None;
        let mut raw_status: Option<&super::super::codec::Value> = None;
        let mut raw_status_element: Option<&super::super::codec::Value> = None;
        let mut raw_experimental: Option<&super::super::codec::Value> = None;
        let mut raw_experimental_element: Option<&super::super::codec::Value> = None;
        let mut raw_date: Option<&super::super::codec::Value> = None;
        let mut raw_date_element: Option<&super::super::codec::Value> = None;
        let mut raw_publisher: Option<&super::super::codec::Value> = None;
        let mut raw_publisher_element: Option<&super::super::codec::Value> = None;
        let mut raw_contact: Option<&super::super::codec::Value> = None;
        let mut raw_description: Option<&super::super::codec::Value> = None;
        let mut raw_description_element: Option<&super::super::codec::Value> = None;
        let mut raw_use_context: Option<&super::super::codec::Value> = None;
        let mut raw_jurisdiction: Option<&super::super::codec::Value> = None;
        let mut raw_purpose: Option<&super::super::codec::Value> = None;
        let mut raw_purpose_element: Option<&super::super::codec::Value> = None;
        let mut raw_copyright: Option<&super::super::codec::Value> = None;
        let mut raw_copyright_element: Option<&super::super::codec::Value> = None;
        let mut raw_structure: Option<&super::super::codec::Value> = None;
        let mut raw_import: Option<&super::super::codec::Value> = None;
        let mut raw_import_element: Option<&super::super::codec::Value> = None;
        let mut raw_group: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "resourceType" => {
                    if value.as_str() != Some("StructureMap") {
                        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);
                }
                "url" => {
                    raw_url = Some(value);
                }
                "_url" => {
                    raw_url_element = Some(value);
                }
                "identifier" => {
                    raw_identifier = Some(value);
                }
                "version" => {
                    raw_version = Some(value);
                }
                "_version" => {
                    raw_version_element = Some(value);
                }
                "name" => {
                    raw_name = Some(value);
                }
                "_name" => {
                    raw_name_element = Some(value);
                }
                "title" => {
                    raw_title = Some(value);
                }
                "_title" => {
                    raw_title_element = Some(value);
                }
                "status" => {
                    raw_status = Some(value);
                }
                "_status" => {
                    raw_status_element = Some(value);
                }
                "experimental" => {
                    raw_experimental = Some(value);
                }
                "_experimental" => {
                    raw_experimental_element = Some(value);
                }
                "date" => {
                    raw_date = Some(value);
                }
                "_date" => {
                    raw_date_element = Some(value);
                }
                "publisher" => {
                    raw_publisher = Some(value);
                }
                "_publisher" => {
                    raw_publisher_element = Some(value);
                }
                "contact" => {
                    raw_contact = Some(value);
                }
                "description" => {
                    raw_description = Some(value);
                }
                "_description" => {
                    raw_description_element = Some(value);
                }
                "useContext" => {
                    raw_use_context = Some(value);
                }
                "jurisdiction" => {
                    raw_jurisdiction = Some(value);
                }
                "purpose" => {
                    raw_purpose = Some(value);
                }
                "_purpose" => {
                    raw_purpose_element = Some(value);
                }
                "copyright" => {
                    raw_copyright = Some(value);
                }
                "_copyright" => {
                    raw_copyright_element = Some(value);
                }
                "structure" => {
                    raw_structure = Some(value);
                }
                "import" => {
                    raw_import = Some(value);
                }
                "_import" => {
                    raw_import_element = Some(value);
                }
                "group" => {
                    raw_group = 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 field_url = path.with("url", |path| {
            super::super::codec::Primitive::from_json_parts(raw_url, raw_url_element, 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_version = match (raw_version, raw_version_element) {
            (None, None) => None,
            (value, element) => Some(path.with("version", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_name = path.with("name", |path| {
            super::super::codec::Primitive::from_json_parts(raw_name, raw_name_element, path)
        })?;
        let field_title = match (raw_title, raw_title_element) {
            (None, None) => None,
            (value, element) => Some(path.with("title", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_status = path.with("status", |path| {
            super::super::codec::Primitive::from_json_parts(raw_status, raw_status_element, path)
        })?;
        let field_experimental = match (raw_experimental, raw_experimental_element) {
            (None, None) => None,
            (value, element) => Some(path.with("experimental", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_date = match (raw_date, raw_date_element) {
            (None, None) => None,
            (value, element) => Some(path.with("date", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_publisher = match (raw_publisher, raw_publisher_element) {
            (None, None) => None,
            (value, element) => Some(path.with("publisher", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_contact = Vec::new();
        if let Some(raw) = raw_contact {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_contact.push(path.with_index("contact", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_description = match (raw_description, raw_description_element) {
            (None, None) => None,
            (value, element) => Some(path.with("description", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_use_context = Vec::new();
        if let Some(raw) = raw_use_context {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_use_context.push(path.with_index("useContext", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_jurisdiction = Vec::new();
        if let Some(raw) = raw_jurisdiction {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_jurisdiction.push(path.with_index("jurisdiction", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_purpose = match (raw_purpose, raw_purpose_element) {
            (None, None) => None,
            (value, element) => Some(path.with("purpose", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_copyright = match (raw_copyright, raw_copyright_element) {
            (None, None) => None,
            (value, element) => Some(path.with("copyright", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_structure = Vec::new();
        if let Some(raw) = raw_structure {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_structure.push(path.with_index("structure", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_import = Vec::new();
        for (index, (value, element)) in
            super::super::codec::pair_arrays(raw_import, raw_import_element, path)?
                .into_iter()
                .enumerate()
        {
            field_import.push(path.with_index("import", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let mut field_group = Vec::new();
        if let Some(raw) = raw_group {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_group.push(path.with_index("group", 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,
            url: field_url,
            identifier: field_identifier,
            version: field_version,
            name: field_name,
            title: field_title,
            status: field_status,
            experimental: field_experimental,
            date: field_date,
            publisher: field_publisher,
            contact: field_contact,
            description: field_description,
            use_context: field_use_context,
            jurisdiction: field_jurisdiction,
            purpose: field_purpose,
            copyright: field_copyright,
            structure: field_structure,
            import: field_import,
            group: field_group,
        })
    }
}

impl serde::Serialize for StructureMap {
    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.copyright {
            super::super::codec::element_entry(&mut map, "_copyright", item)?;
        }
        if let Some(item) = &self.date {
            super::super::codec::element_entry(&mut map, "_date", item)?;
        }
        if let Some(item) = &self.description {
            super::super::codec::element_entry(&mut map, "_description", item)?;
        }
        if let Some(item) = &self.experimental {
            super::super::codec::element_entry(&mut map, "_experimental", item)?;
        }
        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)?;
        }
        super::super::codec::element_list_entry(&mut map, "_import", &self.import)?;
        if let Some(item) = &self.language {
            super::super::codec::element_entry(&mut map, "_language", item)?;
        }
        super::super::codec::element_entry(&mut map, "_name", &self.name)?;
        if let Some(item) = &self.publisher {
            super::super::codec::element_entry(&mut map, "_publisher", item)?;
        }
        if let Some(item) = &self.purpose {
            super::super::codec::element_entry(&mut map, "_purpose", item)?;
        }
        super::super::codec::element_entry(&mut map, "_status", &self.status)?;
        if let Some(item) = &self.title {
            super::super::codec::element_entry(&mut map, "_title", item)?;
        }
        super::super::codec::element_entry(&mut map, "_url", &self.url)?;
        if let Some(item) = &self.version {
            super::super::codec::element_entry(&mut map, "_version", item)?;
        }
        if !self.contact.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "contact", &self.contact)?;
        }
        if !self.contained.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "contained", &self.contained)?;
        }
        if let Some(item) = &self.copyright {
            super::super::codec::value_entry(&mut map, "copyright", item)?;
        }
        if let Some(item) = &self.date {
            super::super::codec::value_entry(&mut map, "date", item)?;
        }
        if let Some(item) = &self.description {
            super::super::codec::value_entry(&mut map, "description", item)?;
        }
        if let Some(item) = &self.experimental {
            super::super::codec::value_entry(&mut map, "experimental", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if !self.group.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "group", &self.group)?;
        }
        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)?;
        }
        super::super::codec::value_list_entry(&mut map, "import", &self.import)?;
        if !self.jurisdiction.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "jurisdiction",
                &self.jurisdiction,
            )?;
        }
        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,
            )?;
        }
        super::super::codec::value_entry(&mut map, "name", &self.name)?;
        if let Some(item) = &self.publisher {
            super::super::codec::value_entry(&mut map, "publisher", item)?;
        }
        if let Some(item) = &self.purpose {
            super::super::codec::value_entry(&mut map, "purpose", item)?;
        }
        serde::ser::SerializeMap::serialize_entry(&mut map, "resourceType", "StructureMap")?;
        super::super::codec::value_entry(&mut map, "status", &self.status)?;
        if !self.structure.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "structure", &self.structure)?;
        }
        if let Some(item) = &self.text {
            serde::ser::SerializeMap::serialize_entry(&mut map, "text", item)?;
        }
        if let Some(item) = &self.title {
            super::super::codec::value_entry(&mut map, "title", item)?;
        }
        super::super::codec::value_entry(&mut map, "url", &self.url)?;
        if !self.use_context.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "useContext", &self.use_context)?;
        }
        if let Some(item) = &self.version {
            super::super::codec::value_entry(&mut map, "version", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for StructureMap {
    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("StructureMap");
        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)
    }
}

/// Named sections for reader convenience
///
/// Organizes the mapping into managable chunks for human review/ease of
/// maintenance.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct StructureMapGroup {
    /// 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>,
    /// Human-readable label
    ///
    /// A unique name for the group for the convenience of human readers.
    pub name: super::primitives::Id,
    /// Another group that this group adds rules to.
    pub extends: Option<super::primitives::Id>,
    /// none | types | type-and-types
    ///
    /// If this is the default rule set to apply for thie source type, or this
    /// combination of types.
    pub type_mode: super::primitives::Code,
    /// Additional description/explaination for group
    ///
    /// Additional supporting documentation that explains the purpose of the group
    /// and the types of mappings within it.
    pub documentation: Option<super::primitives::String>,
    /// Named instance provided when invoking the map
    ///
    /// A name assigned to an instance of data. The instance must be provided when
    /// the mapping is invoked.
    pub input: Vec<StructureMapGroupInput>,
    /// Transform Rule from source to target.
    pub rule: Vec<StructureMapGroupRule>,
}

impl super::super::codec::Json for StructureMapGroup {
    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.name)? {
            object.insert(std::string::String::from("name"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.name)? {
            object.insert(std::string::String::from("_name"), e);
        }
        if let Some(item) = &self.extends {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("extends"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_extends"), e);
            }
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.type_mode)? {
            object.insert(std::string::String::from("typeMode"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.type_mode)? {
            object.insert(std::string::String::from("_typeMode"), e);
        }
        if let Some(item) = &self.documentation {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("documentation"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_documentation"), e);
            }
        }
        if !self.input.is_empty() {
            let mut items = Vec::with_capacity(self.input.len());
            for item in &self.input {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("input"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.rule.is_empty() {
            let mut items = Vec::with_capacity(self.rule.len());
            for item in &self.rule {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("rule"),
                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_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: 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_extends: Option<&super::super::codec::Value> = None;
        let mut raw_extends_element: Option<&super::super::codec::Value> = None;
        let mut raw_type_mode: Option<&super::super::codec::Value> = None;
        let mut raw_type_mode_element: Option<&super::super::codec::Value> = None;
        let mut raw_documentation: Option<&super::super::codec::Value> = None;
        let mut raw_documentation_element: Option<&super::super::codec::Value> = None;
        let mut raw_input: Option<&super::super::codec::Value> = None;
        let mut raw_rule: 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);
                }
                "name" => {
                    raw_name = Some(value);
                }
                "_name" => {
                    raw_name_element = Some(value);
                }
                "extends" => {
                    raw_extends = Some(value);
                }
                "_extends" => {
                    raw_extends_element = Some(value);
                }
                "typeMode" => {
                    raw_type_mode = Some(value);
                }
                "_typeMode" => {
                    raw_type_mode_element = Some(value);
                }
                "documentation" => {
                    raw_documentation = Some(value);
                }
                "_documentation" => {
                    raw_documentation_element = Some(value);
                }
                "input" => {
                    raw_input = Some(value);
                }
                "rule" => {
                    raw_rule = 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_name = path.with("name", |path| {
            super::super::codec::Primitive::from_json_parts(raw_name, raw_name_element, path)
        })?;
        let field_extends = match (raw_extends, raw_extends_element) {
            (None, None) => None,
            (value, element) => Some(path.with("extends", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_type_mode = path.with("typeMode", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_type_mode,
                raw_type_mode_element,
                path,
            )
        })?;
        let field_documentation = match (raw_documentation, raw_documentation_element) {
            (None, None) => None,
            (value, element) => Some(path.with("documentation", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_input = Vec::new();
        if let Some(raw) = raw_input {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_input.push(path.with_index("input", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_rule = Vec::new();
        if let Some(raw) = raw_rule {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_rule.push(path.with_index("rule", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            name: field_name,
            extends: field_extends,
            type_mode: field_type_mode,
            documentation: field_documentation,
            input: field_input,
            rule: field_rule,
        })
    }
}

impl serde::Serialize for StructureMapGroup {
    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.documentation {
            super::super::codec::element_entry(&mut map, "_documentation", item)?;
        }
        if let Some(item) = &self.extends {
            super::super::codec::element_entry(&mut map, "_extends", item)?;
        }
        super::super::codec::element_entry(&mut map, "_name", &self.name)?;
        super::super::codec::element_entry(&mut map, "_typeMode", &self.type_mode)?;
        if let Some(item) = &self.documentation {
            super::super::codec::value_entry(&mut map, "documentation", item)?;
        }
        if let Some(item) = &self.extends {
            super::super::codec::value_entry(&mut map, "extends", 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.input.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "input", &self.input)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        super::super::codec::value_entry(&mut map, "name", &self.name)?;
        if !self.rule.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "rule", &self.rule)?;
        }
        super::super::codec::value_entry(&mut map, "typeMode", &self.type_mode)?;
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for StructureMapGroup {
    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("StructureMapGroup");
        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)
    }
}

/// Named instance provided when invoking the map
///
/// A name assigned to an instance of data. The instance must be provided when
/// the mapping is invoked.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct StructureMapGroupInput {
    /// 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>,
    /// Name for this instance of data.
    pub name: super::primitives::Id,
    /// Type for this instance of data.
    pub r#type: Option<super::primitives::String>,
    /// source | target
    ///
    /// Mode for this instance of data.
    pub mode: super::primitives::Code,
    /// Documentation for this instance of data.
    pub documentation: Option<super::primitives::String>,
}

impl super::super::codec::Json for StructureMapGroupInput {
    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.name)? {
            object.insert(std::string::String::from("name"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.name)? {
            object.insert(std::string::String::from("_name"), e);
        }
        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.mode)? {
            object.insert(std::string::String::from("mode"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.mode)? {
            object.insert(std::string::String::from("_mode"), e);
        }
        if let Some(item) = &self.documentation {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("documentation"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_documentation"), 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_name: Option<&super::super::codec::Value> = None;
        let mut raw_name_element: 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_mode: Option<&super::super::codec::Value> = None;
        let mut raw_mode_element: Option<&super::super::codec::Value> = None;
        let mut raw_documentation: Option<&super::super::codec::Value> = None;
        let mut raw_documentation_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);
                }
                "name" => {
                    raw_name = Some(value);
                }
                "_name" => {
                    raw_name_element = Some(value);
                }
                "type" => {
                    raw_type = Some(value);
                }
                "_type" => {
                    raw_type_element = Some(value);
                }
                "mode" => {
                    raw_mode = Some(value);
                }
                "_mode" => {
                    raw_mode_element = Some(value);
                }
                "documentation" => {
                    raw_documentation = Some(value);
                }
                "_documentation" => {
                    raw_documentation_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_name = path.with("name", |path| {
            super::super::codec::Primitive::from_json_parts(raw_name, raw_name_element, 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_mode = path.with("mode", |path| {
            super::super::codec::Primitive::from_json_parts(raw_mode, raw_mode_element, path)
        })?;
        let field_documentation = match (raw_documentation, raw_documentation_element) {
            (None, None) => None,
            (value, element) => Some(path.with("documentation", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            name: field_name,
            r#type: field_type,
            mode: field_mode,
            documentation: field_documentation,
        })
    }
}

impl serde::Serialize for StructureMapGroupInput {
    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.documentation {
            super::super::codec::element_entry(&mut map, "_documentation", item)?;
        }
        super::super::codec::element_entry(&mut map, "_mode", &self.mode)?;
        super::super::codec::element_entry(&mut map, "_name", &self.name)?;
        if let Some(item) = &self.r#type {
            super::super::codec::element_entry(&mut map, "_type", item)?;
        }
        if let Some(item) = &self.documentation {
            super::super::codec::value_entry(&mut map, "documentation", 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)?;
        }
        super::super::codec::value_entry(&mut map, "mode", &self.mode)?;
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        super::super::codec::value_entry(&mut map, "name", &self.name)?;
        if let Some(item) = &self.r#type {
            super::super::codec::value_entry(&mut map, "type", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for StructureMapGroupInput {
    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("StructureMapGroupInput");
        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)
    }
}

/// Transform Rule from source to target.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct StructureMapGroupRule {
    /// 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>,
    /// Name of the rule for internal references.
    pub name: super::primitives::Id,
    /// Source inputs to the mapping.
    pub source: Vec<StructureMapGroupRuleSource>,
    /// Content to create because of this mapping rule.
    pub target: Vec<StructureMapGroupRuleTarget>,
    /// Rules contained in this rule.
    pub rule: Vec<StructureMapGroupRule>,
    /// Which other rules to apply in the context of this rule.
    pub dependent: Vec<StructureMapGroupRuleDependent>,
    /// Documentation for this instance of data.
    pub documentation: Option<super::primitives::String>,
}

impl super::super::codec::Json for StructureMapGroupRule {
    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.name)? {
            object.insert(std::string::String::from("name"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.name)? {
            object.insert(std::string::String::from("_name"), e);
        }
        if !self.source.is_empty() {
            let mut items = Vec::with_capacity(self.source.len());
            for item in &self.source {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("source"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.target.is_empty() {
            let mut items = Vec::with_capacity(self.target.len());
            for item in &self.target {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("target"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.rule.is_empty() {
            let mut items = Vec::with_capacity(self.rule.len());
            for item in &self.rule {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("rule"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.dependent.is_empty() {
            let mut items = Vec::with_capacity(self.dependent.len());
            for item in &self.dependent {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("dependent"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.documentation {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("documentation"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_documentation"), 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_name: Option<&super::super::codec::Value> = None;
        let mut raw_name_element: Option<&super::super::codec::Value> = None;
        let mut raw_source: Option<&super::super::codec::Value> = None;
        let mut raw_target: Option<&super::super::codec::Value> = None;
        let mut raw_rule: Option<&super::super::codec::Value> = None;
        let mut raw_dependent: Option<&super::super::codec::Value> = None;
        let mut raw_documentation: Option<&super::super::codec::Value> = None;
        let mut raw_documentation_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);
                }
                "name" => {
                    raw_name = Some(value);
                }
                "_name" => {
                    raw_name_element = Some(value);
                }
                "source" => {
                    raw_source = Some(value);
                }
                "target" => {
                    raw_target = Some(value);
                }
                "rule" => {
                    raw_rule = Some(value);
                }
                "dependent" => {
                    raw_dependent = Some(value);
                }
                "documentation" => {
                    raw_documentation = Some(value);
                }
                "_documentation" => {
                    raw_documentation_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_name = path.with("name", |path| {
            super::super::codec::Primitive::from_json_parts(raw_name, raw_name_element, path)
        })?;
        let mut field_source = Vec::new();
        if let Some(raw) = raw_source {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_source.push(path.with_index("source", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_target = Vec::new();
        if let Some(raw) = raw_target {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_target.push(path.with_index("target", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_rule = Vec::new();
        if let Some(raw) = raw_rule {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_rule.push(path.with_index("rule", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_dependent = Vec::new();
        if let Some(raw) = raw_dependent {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_dependent.push(path.with_index("dependent", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_documentation = match (raw_documentation, raw_documentation_element) {
            (None, None) => None,
            (value, element) => Some(path.with("documentation", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            name: field_name,
            source: field_source,
            target: field_target,
            rule: field_rule,
            dependent: field_dependent,
            documentation: field_documentation,
        })
    }
}

impl serde::Serialize for StructureMapGroupRule {
    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.documentation {
            super::super::codec::element_entry(&mut map, "_documentation", item)?;
        }
        super::super::codec::element_entry(&mut map, "_name", &self.name)?;
        if !self.dependent.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "dependent", &self.dependent)?;
        }
        if let Some(item) = &self.documentation {
            super::super::codec::value_entry(&mut map, "documentation", 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,
            )?;
        }
        super::super::codec::value_entry(&mut map, "name", &self.name)?;
        if !self.rule.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "rule", &self.rule)?;
        }
        if !self.source.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "source", &self.source)?;
        }
        if !self.target.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "target", &self.target)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for StructureMapGroupRule {
    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("StructureMapGroupRule");
        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)
    }
}

/// Which other rules to apply in the context of this rule.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct StructureMapGroupRuleDependent {
    /// 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>,
    /// Name of a rule or group to apply.
    pub name: super::primitives::Id,
    /// Variable to pass to the rule or group.
    pub variable: Vec<super::primitives::String>,
}

impl super::super::codec::Json for StructureMapGroupRuleDependent {
    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.name)? {
            object.insert(std::string::String::from("name"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.name)? {
            object.insert(std::string::String::from("_name"), e);
        }
        if !self.variable.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.variable)?;
            object.insert(std::string::String::from("variable"), values);
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_variable"), elements);
            }
        }
        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_name: Option<&super::super::codec::Value> = None;
        let mut raw_name_element: Option<&super::super::codec::Value> = None;
        let mut raw_variable: Option<&super::super::codec::Value> = None;
        let mut raw_variable_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);
                }
                "name" => {
                    raw_name = Some(value);
                }
                "_name" => {
                    raw_name_element = Some(value);
                }
                "variable" => {
                    raw_variable = Some(value);
                }
                "_variable" => {
                    raw_variable_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_name = path.with("name", |path| {
            super::super::codec::Primitive::from_json_parts(raw_name, raw_name_element, path)
        })?;
        let mut field_variable = Vec::new();
        for (index, (value, element)) in
            super::super::codec::pair_arrays(raw_variable, raw_variable_element, path)?
                .into_iter()
                .enumerate()
        {
            field_variable.push(path.with_index("variable", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            name: field_name,
            variable: field_variable,
        })
    }
}

impl serde::Serialize for StructureMapGroupRuleDependent {
    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, "_name", &self.name)?;
        super::super::codec::element_list_entry(&mut map, "_variable", &self.variable)?;
        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,
            )?;
        }
        super::super::codec::value_entry(&mut map, "name", &self.name)?;
        super::super::codec::value_list_entry(&mut map, "variable", &self.variable)?;
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for StructureMapGroupRuleDependent {
    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("StructureMapGroupRuleDependent");
        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)
    }
}

/// Source inputs to the mapping.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct StructureMapGroupRuleSource {
    /// 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>,
    /// Type or variable this rule applies to.
    pub context: super::primitives::Id,
    /// Specified minimum cardinality
    ///
    /// Specified minimum cardinality for the element. This is optional; if present,
    /// it acts an implicit check on the input content.
    pub min: Option<super::primitives::Integer>,
    /// Specified maximum cardinality (number or \*)
    ///
    /// Specified maximum cardinality for the element - a number or a "\*". This is
    /// optional; if present, it acts an implicit check on the input content (\*
    /// just serves as documentation; it's the default value).
    pub max: Option<super::primitives::String>,
    /// Rule only applies if source has this type
    ///
    /// Specified type for the element. This works as a condition on the mapping -
    /// use for polymorphic elements.
    pub r#type: Option<super::primitives::String>,
    /// Default value if no value exists
    ///
    /// A value to use if there is no existing value in the source object.
    pub default_value: Option<StructureMapGroupRuleSourceDefaultValue>,
    /// Optional field for this source.
    pub element: Option<super::primitives::String>,
    /// first | not\_first | last | not\_last | only\_one
    ///
    /// How to handle the list mode for this element.
    pub list_mode: Option<super::primitives::Code>,
    /// Named context for field, if a field is specified.
    pub variable: Option<super::primitives::Id>,
    /// FHIRPath expression - must be true or the rule does not apply.
    pub condition: Option<super::primitives::String>,
    /// FHIRPath expression - must be true or the mapping engine throws an error
    /// instead of completing.
    pub check: Option<super::primitives::String>,
}

impl super::super::codec::Json for StructureMapGroupRuleSource {
    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.context)? {
            object.insert(std::string::String::from("context"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.context)? {
            object.insert(std::string::String::from("_context"), e);
        }
        if let Some(item) = &self.min {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("min"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_min"), e);
            }
        }
        if let Some(item) = &self.max {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("max"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_max"), e);
            }
        }
        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(item) = &self.default_value {
            let (suffix, value, element) = item.to_json_parts()?;
            if let Some(value) = value {
                object.insert(format!("defaultValue{suffix}"), value);
            }
            if let Some(element) = element {
                object.insert(format!("_defaultValue{suffix}"), element);
            }
        }
        if let Some(item) = &self.element {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("element"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_element"), e);
            }
        }
        if let Some(item) = &self.list_mode {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("listMode"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_listMode"), e);
            }
        }
        if let Some(item) = &self.variable {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("variable"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_variable"), e);
            }
        }
        if let Some(item) = &self.condition {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("condition"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_condition"), e);
            }
        }
        if let Some(item) = &self.check {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("check"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_check"), 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_context: Option<&super::super::codec::Value> = None;
        let mut raw_context_element: Option<&super::super::codec::Value> = None;
        let mut raw_min: Option<&super::super::codec::Value> = None;
        let mut raw_min_element: Option<&super::super::codec::Value> = None;
        let mut raw_max: Option<&super::super::codec::Value> = None;
        let mut raw_max_element: 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_default_value = super::super::codec::ChoiceSlot::default();
        let mut raw_element: Option<&super::super::codec::Value> = None;
        let mut raw_element_element: Option<&super::super::codec::Value> = None;
        let mut raw_list_mode: Option<&super::super::codec::Value> = None;
        let mut raw_list_mode_element: Option<&super::super::codec::Value> = None;
        let mut raw_variable: Option<&super::super::codec::Value> = None;
        let mut raw_variable_element: Option<&super::super::codec::Value> = None;
        let mut raw_condition: Option<&super::super::codec::Value> = None;
        let mut raw_condition_element: Option<&super::super::codec::Value> = None;
        let mut raw_check: Option<&super::super::codec::Value> = None;
        let mut raw_check_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);
                }
                "context" => {
                    raw_context = Some(value);
                }
                "_context" => {
                    raw_context_element = Some(value);
                }
                "min" => {
                    raw_min = Some(value);
                }
                "_min" => {
                    raw_min_element = Some(value);
                }
                "max" => {
                    raw_max = Some(value);
                }
                "_max" => {
                    raw_max_element = Some(value);
                }
                "type" => {
                    raw_type = Some(value);
                }
                "_type" => {
                    raw_type_element = Some(value);
                }
                "defaultValueBase64Binary" => {
                    raw_default_value.value("Base64Binary", value, path)?;
                }
                "_defaultValueBase64Binary" => {
                    raw_default_value.element("Base64Binary", value, path)?;
                }
                "defaultValueBoolean" => {
                    raw_default_value.value("Boolean", value, path)?;
                }
                "_defaultValueBoolean" => {
                    raw_default_value.element("Boolean", value, path)?;
                }
                "defaultValueCode" => {
                    raw_default_value.value("Code", value, path)?;
                }
                "_defaultValueCode" => {
                    raw_default_value.element("Code", value, path)?;
                }
                "defaultValueDate" => {
                    raw_default_value.value("Date", value, path)?;
                }
                "_defaultValueDate" => {
                    raw_default_value.element("Date", value, path)?;
                }
                "defaultValueDateTime" => {
                    raw_default_value.value("DateTime", value, path)?;
                }
                "_defaultValueDateTime" => {
                    raw_default_value.element("DateTime", value, path)?;
                }
                "defaultValueDecimal" => {
                    raw_default_value.value("Decimal", value, path)?;
                }
                "_defaultValueDecimal" => {
                    raw_default_value.element("Decimal", value, path)?;
                }
                "defaultValueId" => {
                    raw_default_value.value("Id", value, path)?;
                }
                "_defaultValueId" => {
                    raw_default_value.element("Id", value, path)?;
                }
                "defaultValueInstant" => {
                    raw_default_value.value("Instant", value, path)?;
                }
                "_defaultValueInstant" => {
                    raw_default_value.element("Instant", value, path)?;
                }
                "defaultValueInteger" => {
                    raw_default_value.value("Integer", value, path)?;
                }
                "_defaultValueInteger" => {
                    raw_default_value.element("Integer", value, path)?;
                }
                "defaultValueMarkdown" => {
                    raw_default_value.value("Markdown", value, path)?;
                }
                "_defaultValueMarkdown" => {
                    raw_default_value.element("Markdown", value, path)?;
                }
                "defaultValueOid" => {
                    raw_default_value.value("Oid", value, path)?;
                }
                "_defaultValueOid" => {
                    raw_default_value.element("Oid", value, path)?;
                }
                "defaultValuePositiveInt" => {
                    raw_default_value.value("PositiveInt", value, path)?;
                }
                "_defaultValuePositiveInt" => {
                    raw_default_value.element("PositiveInt", value, path)?;
                }
                "defaultValueString" => {
                    raw_default_value.value("String", value, path)?;
                }
                "_defaultValueString" => {
                    raw_default_value.element("String", value, path)?;
                }
                "defaultValueTime" => {
                    raw_default_value.value("Time", value, path)?;
                }
                "_defaultValueTime" => {
                    raw_default_value.element("Time", value, path)?;
                }
                "defaultValueUnsignedInt" => {
                    raw_default_value.value("UnsignedInt", value, path)?;
                }
                "_defaultValueUnsignedInt" => {
                    raw_default_value.element("UnsignedInt", value, path)?;
                }
                "defaultValueUri" => {
                    raw_default_value.value("Uri", value, path)?;
                }
                "_defaultValueUri" => {
                    raw_default_value.element("Uri", value, path)?;
                }
                "defaultValueAddress" => {
                    raw_default_value.value("Address", value, path)?;
                }
                "_defaultValueAddress" => {
                    raw_default_value.element("Address", value, path)?;
                }
                "defaultValueAge" => {
                    raw_default_value.value("Age", value, path)?;
                }
                "_defaultValueAge" => {
                    raw_default_value.element("Age", value, path)?;
                }
                "defaultValueAnnotation" => {
                    raw_default_value.value("Annotation", value, path)?;
                }
                "_defaultValueAnnotation" => {
                    raw_default_value.element("Annotation", value, path)?;
                }
                "defaultValueAttachment" => {
                    raw_default_value.value("Attachment", value, path)?;
                }
                "_defaultValueAttachment" => {
                    raw_default_value.element("Attachment", value, path)?;
                }
                "defaultValueCodeableConcept" => {
                    raw_default_value.value("CodeableConcept", value, path)?;
                }
                "_defaultValueCodeableConcept" => {
                    raw_default_value.element("CodeableConcept", value, path)?;
                }
                "defaultValueCoding" => {
                    raw_default_value.value("Coding", value, path)?;
                }
                "_defaultValueCoding" => {
                    raw_default_value.element("Coding", value, path)?;
                }
                "defaultValueContactPoint" => {
                    raw_default_value.value("ContactPoint", value, path)?;
                }
                "_defaultValueContactPoint" => {
                    raw_default_value.element("ContactPoint", value, path)?;
                }
                "defaultValueCount" => {
                    raw_default_value.value("Count", value, path)?;
                }
                "_defaultValueCount" => {
                    raw_default_value.element("Count", value, path)?;
                }
                "defaultValueDistance" => {
                    raw_default_value.value("Distance", value, path)?;
                }
                "_defaultValueDistance" => {
                    raw_default_value.element("Distance", value, path)?;
                }
                "defaultValueDuration" => {
                    raw_default_value.value("Duration", value, path)?;
                }
                "_defaultValueDuration" => {
                    raw_default_value.element("Duration", value, path)?;
                }
                "defaultValueHumanName" => {
                    raw_default_value.value("HumanName", value, path)?;
                }
                "_defaultValueHumanName" => {
                    raw_default_value.element("HumanName", value, path)?;
                }
                "defaultValueIdentifier" => {
                    raw_default_value.value("Identifier", value, path)?;
                }
                "_defaultValueIdentifier" => {
                    raw_default_value.element("Identifier", value, path)?;
                }
                "defaultValueMoney" => {
                    raw_default_value.value("Money", value, path)?;
                }
                "_defaultValueMoney" => {
                    raw_default_value.element("Money", value, path)?;
                }
                "defaultValuePeriod" => {
                    raw_default_value.value("Period", value, path)?;
                }
                "_defaultValuePeriod" => {
                    raw_default_value.element("Period", value, path)?;
                }
                "defaultValueQuantity" => {
                    raw_default_value.value("Quantity", value, path)?;
                }
                "_defaultValueQuantity" => {
                    raw_default_value.element("Quantity", value, path)?;
                }
                "defaultValueRange" => {
                    raw_default_value.value("Range", value, path)?;
                }
                "_defaultValueRange" => {
                    raw_default_value.element("Range", value, path)?;
                }
                "defaultValueRatio" => {
                    raw_default_value.value("Ratio", value, path)?;
                }
                "_defaultValueRatio" => {
                    raw_default_value.element("Ratio", value, path)?;
                }
                "defaultValueReference" => {
                    raw_default_value.value("Reference", value, path)?;
                }
                "_defaultValueReference" => {
                    raw_default_value.element("Reference", value, path)?;
                }
                "defaultValueSampledData" => {
                    raw_default_value.value("SampledData", value, path)?;
                }
                "_defaultValueSampledData" => {
                    raw_default_value.element("SampledData", value, path)?;
                }
                "defaultValueSignature" => {
                    raw_default_value.value("Signature", value, path)?;
                }
                "_defaultValueSignature" => {
                    raw_default_value.element("Signature", value, path)?;
                }
                "defaultValueTiming" => {
                    raw_default_value.value("Timing", value, path)?;
                }
                "_defaultValueTiming" => {
                    raw_default_value.element("Timing", value, path)?;
                }
                "defaultValueMeta" => {
                    raw_default_value.value("Meta", value, path)?;
                }
                "_defaultValueMeta" => {
                    raw_default_value.element("Meta", value, path)?;
                }
                "element" => {
                    raw_element = Some(value);
                }
                "_element" => {
                    raw_element_element = Some(value);
                }
                "listMode" => {
                    raw_list_mode = Some(value);
                }
                "_listMode" => {
                    raw_list_mode_element = Some(value);
                }
                "variable" => {
                    raw_variable = Some(value);
                }
                "_variable" => {
                    raw_variable_element = Some(value);
                }
                "condition" => {
                    raw_condition = Some(value);
                }
                "_condition" => {
                    raw_condition_element = Some(value);
                }
                "check" => {
                    raw_check = Some(value);
                }
                "_check" => {
                    raw_check_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_context = path.with("context", |path| {
            super::super::codec::Primitive::from_json_parts(raw_context, raw_context_element, path)
        })?;
        let field_min = match (raw_min, raw_min_element) {
            (None, None) => None,
            (value, element) => Some(path.with("min", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_max = match (raw_max, raw_max_element) {
            (None, None) => None,
            (value, element) => Some(path.with("max", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, 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_default_value = match raw_default_value.suffix {
            None => None,
            Some(suffix) => Some(path.with("defaultValue", |path| {
                StructureMapGroupRuleSourceDefaultValue::from_json_parts(
                    suffix,
                    raw_default_value.value,
                    raw_default_value.element,
                    path,
                )
            })?),
        };
        let field_element = match (raw_element, raw_element_element) {
            (None, None) => None,
            (value, element) => Some(path.with("element", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_list_mode = match (raw_list_mode, raw_list_mode_element) {
            (None, None) => None,
            (value, element) => Some(path.with("listMode", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_variable = match (raw_variable, raw_variable_element) {
            (None, None) => None,
            (value, element) => Some(path.with("variable", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_condition = match (raw_condition, raw_condition_element) {
            (None, None) => None,
            (value, element) => Some(path.with("condition", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_check = match (raw_check, raw_check_element) {
            (None, None) => None,
            (value, element) => Some(path.with("check", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            context: field_context,
            min: field_min,
            max: field_max,
            r#type: field_type,
            default_value: field_default_value,
            element: field_element,
            list_mode: field_list_mode,
            variable: field_variable,
            condition: field_condition,
            check: field_check,
        })
    }
}

impl serde::Serialize for StructureMapGroupRuleSource {
    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.check {
            super::super::codec::element_entry(&mut map, "_check", item)?;
        }
        if let Some(item) = &self.condition {
            super::super::codec::element_entry(&mut map, "_condition", item)?;
        }
        super::super::codec::element_entry(&mut map, "_context", &self.context)?;
        match &self.default_value {
            Some(StructureMapGroupRuleSourceDefaultValue::Base64Binary(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueBase64Binary", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Boolean(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueBoolean", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Code(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueCode", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Date(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueDate", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::DateTime(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueDateTime", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Decimal(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueDecimal", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Id(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueId", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Instant(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueInstant", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Integer(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueInteger", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Markdown(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueMarkdown", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Oid(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueOid", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::PositiveInt(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValuePositiveInt", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::String(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueString", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Time(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueTime", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::UnsignedInt(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueUnsignedInt", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Uri(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueUri", inner)?;
            }
            _ => {}
        }
        if let Some(item) = &self.element {
            super::super::codec::element_entry(&mut map, "_element", item)?;
        }
        if let Some(item) = &self.list_mode {
            super::super::codec::element_entry(&mut map, "_listMode", item)?;
        }
        if let Some(item) = &self.max {
            super::super::codec::element_entry(&mut map, "_max", item)?;
        }
        if let Some(item) = &self.min {
            super::super::codec::element_entry(&mut map, "_min", item)?;
        }
        if let Some(item) = &self.r#type {
            super::super::codec::element_entry(&mut map, "_type", item)?;
        }
        if let Some(item) = &self.variable {
            super::super::codec::element_entry(&mut map, "_variable", item)?;
        }
        if let Some(item) = &self.check {
            super::super::codec::value_entry(&mut map, "check", item)?;
        }
        if let Some(item) = &self.condition {
            super::super::codec::value_entry(&mut map, "condition", item)?;
        }
        super::super::codec::value_entry(&mut map, "context", &self.context)?;
        match &self.default_value {
            Some(StructureMapGroupRuleSourceDefaultValue::Address(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueAddress",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Age(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueAge",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Annotation(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueAnnotation",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Attachment(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueAttachment",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Base64Binary(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueBase64Binary", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Boolean(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueBoolean", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Code(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueCode", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::CodeableConcept(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueCodeableConcept",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Coding(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueCoding",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::ContactPoint(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueContactPoint",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Count(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueCount",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Date(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueDate", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::DateTime(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueDateTime", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Decimal(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueDecimal", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Distance(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueDistance",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Duration(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueDuration",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::HumanName(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueHumanName",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Id(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueId", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Identifier(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueIdentifier",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Instant(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueInstant", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Integer(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueInteger", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Markdown(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueMarkdown", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Meta(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueMeta",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Money(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueMoney",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Oid(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueOid", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Period(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValuePeriod",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::PositiveInt(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValuePositiveInt", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Quantity(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueQuantity",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Range(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueRange",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Ratio(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueRatio",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Reference(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueReference",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::SampledData(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueSampledData",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Signature(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueSignature",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::String(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueString", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Time(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueTime", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Timing(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueTiming",
                    inner.as_ref(),
                )?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::UnsignedInt(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueUnsignedInt", inner)?;
            }
            Some(StructureMapGroupRuleSourceDefaultValue::Uri(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueUri", inner)?;
            }
            None => {}
        }
        if let Some(item) = &self.element {
            super::super::codec::value_entry(&mut map, "element", 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 let Some(item) = &self.list_mode {
            super::super::codec::value_entry(&mut map, "listMode", item)?;
        }
        if let Some(item) = &self.max {
            super::super::codec::value_entry(&mut map, "max", item)?;
        }
        if let Some(item) = &self.min {
            super::super::codec::value_entry(&mut map, "min", item)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if let Some(item) = &self.r#type {
            super::super::codec::value_entry(&mut map, "type", item)?;
        }
        if let Some(item) = &self.variable {
            super::super::codec::value_entry(&mut map, "variable", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for StructureMapGroupRuleSource {
    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("StructureMapGroupRuleSource");
        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)
    }
}

/// The \`defaultValue\[x\]\` choice of \`StructureMapGroupRuleSource\`.
///
/// A value to use if there is no existing value in the source object.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum StructureMapGroupRuleSourceDefaultValue {
    /// The `base64Binary` form.
    Base64Binary(super::primitives::Base64Binary),
    /// The `boolean` form.
    Boolean(super::primitives::Boolean),
    /// The `code` form.
    Code(super::primitives::Code),
    /// The `date` form.
    Date(super::primitives::Date),
    /// The `dateTime` form.
    DateTime(super::primitives::DateTime),
    /// The `decimal` form.
    Decimal(super::primitives::Decimal),
    /// The `id` form.
    Id(super::primitives::Id),
    /// The `instant` form.
    Instant(super::primitives::Instant),
    /// The `integer` form.
    Integer(super::primitives::Integer),
    /// The `markdown` form.
    Markdown(super::primitives::Markdown),
    /// The `oid` form.
    Oid(super::primitives::Oid),
    /// The `positiveInt` form.
    PositiveInt(super::primitives::PositiveInt),
    /// The `string` form.
    String(super::primitives::String),
    /// The `time` form.
    Time(super::primitives::Time),
    /// The `unsignedInt` form.
    UnsignedInt(super::primitives::UnsignedInt),
    /// The `uri` form.
    Uri(super::primitives::Uri),
    /// The `Address` form.
    Address(Box<super::address::Address>),
    /// The `Age` form.
    Age(Box<super::age::Age>),
    /// The `Annotation` form.
    Annotation(Box<super::annotation::Annotation>),
    /// The `Attachment` form.
    Attachment(Box<super::attachment::Attachment>),
    /// The `CodeableConcept` form.
    CodeableConcept(Box<super::codeable_concept::CodeableConcept>),
    /// The `Coding` form.
    Coding(Box<super::coding::Coding>),
    /// The `ContactPoint` form.
    ContactPoint(Box<super::contact_point::ContactPoint>),
    /// The `Count` form.
    Count(Box<super::count::Count>),
    /// The `Distance` form.
    Distance(Box<super::distance::Distance>),
    /// The `Duration` form.
    Duration(Box<super::duration::Duration>),
    /// The `HumanName` form.
    HumanName(Box<super::human_name::HumanName>),
    /// The `Identifier` form.
    Identifier(Box<super::identifier::Identifier>),
    /// The `Money` form.
    Money(Box<super::money::Money>),
    /// The `Period` form.
    Period(Box<super::period::Period>),
    /// The `Quantity` form.
    Quantity(Box<super::quantity::Quantity>),
    /// The `Range` form.
    Range(Box<super::range::Range>),
    /// The `Ratio` form.
    Ratio(Box<super::ratio::Ratio>),
    /// The `Reference` form.
    Reference(Box<super::reference::Reference>),
    /// The `SampledData` form.
    SampledData(Box<super::sampled_data::SampledData>),
    /// The `Signature` form.
    Signature(Box<super::signature::Signature>),
    /// The `Timing` form.
    Timing(Box<super::timing::Timing>),
    /// The `Meta` form.
    Meta(Box<super::meta::Meta>),
}

impl StructureMapGroupRuleSourceDefaultValue {
    /// The key suffix, the value part, and the `_name` part of this form.
    ///
    /// # Errors
    ///
    /// Returns [`super::super::codec::EncodeError`] when a held value has no JSON form.
    pub fn to_json_parts(
        &self,
    ) -> Result<
        (
            &'static str,
            Option<super::super::codec::Value>,
            Option<super::super::codec::Value>,
        ),
        super::super::codec::EncodeError,
    > {
        match self {
            Self::Base64Binary(inner) => Ok((
                "Base64Binary",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Boolean(inner) => Ok((
                "Boolean",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Code(inner) => Ok((
                "Code",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Date(inner) => Ok((
                "Date",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::DateTime(inner) => Ok((
                "DateTime",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Decimal(inner) => Ok((
                "Decimal",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Id(inner) => Ok((
                "Id",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Instant(inner) => Ok((
                "Instant",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Integer(inner) => Ok((
                "Integer",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Markdown(inner) => Ok((
                "Markdown",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Oid(inner) => Ok((
                "Oid",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::PositiveInt(inner) => Ok((
                "PositiveInt",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::String(inner) => Ok((
                "String",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Time(inner) => Ok((
                "Time",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::UnsignedInt(inner) => Ok((
                "UnsignedInt",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Uri(inner) => Ok((
                "Uri",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Address(inner) => Ok((
                "Address",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Age(inner) => Ok((
                "Age",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Annotation(inner) => Ok((
                "Annotation",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Attachment(inner) => Ok((
                "Attachment",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::CodeableConcept(inner) => Ok((
                "CodeableConcept",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Coding(inner) => Ok((
                "Coding",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::ContactPoint(inner) => Ok((
                "ContactPoint",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Count(inner) => Ok((
                "Count",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Distance(inner) => Ok((
                "Distance",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Duration(inner) => Ok((
                "Duration",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::HumanName(inner) => Ok((
                "HumanName",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Identifier(inner) => Ok((
                "Identifier",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Money(inner) => Ok((
                "Money",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Period(inner) => Ok((
                "Period",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Quantity(inner) => Ok((
                "Quantity",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Range(inner) => Ok((
                "Range",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Ratio(inner) => Ok((
                "Ratio",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Reference(inner) => Ok((
                "Reference",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::SampledData(inner) => Ok((
                "SampledData",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Signature(inner) => Ok((
                "Signature",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Timing(inner) => Ok((
                "Timing",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Meta(inner) => Ok((
                "Meta",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
        }
    }

    /// Decodes the form named by `suffix` from its value and `_name` parts.
    ///
    /// # Errors
    ///
    /// Returns [`super::super::codec::DecodeError`] for an unknown suffix or a malformed part.
    pub fn from_json_parts(
        suffix: &str,
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        match suffix {
            "Base64Binary" => Ok(Self::Base64Binary(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Boolean" => Ok(Self::Boolean(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Code" => Ok(Self::Code(super::super::codec::Primitive::from_json_parts(
                value, element, path,
            )?)),
            "Date" => Ok(Self::Date(super::super::codec::Primitive::from_json_parts(
                value, element, path,
            )?)),
            "DateTime" => Ok(Self::DateTime(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Decimal" => Ok(Self::Decimal(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Id" => Ok(Self::Id(super::super::codec::Primitive::from_json_parts(
                value, element, path,
            )?)),
            "Instant" => Ok(Self::Instant(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Integer" => Ok(Self::Integer(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Markdown" => Ok(Self::Markdown(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Oid" => Ok(Self::Oid(super::super::codec::Primitive::from_json_parts(
                value, element, path,
            )?)),
            "PositiveInt" => Ok(Self::PositiveInt(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "String" => Ok(Self::String(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Time" => Ok(Self::Time(super::super::codec::Primitive::from_json_parts(
                value, element, path,
            )?)),
            "UnsignedInt" => Ok(Self::UnsignedInt(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Uri" => Ok(Self::Uri(super::super::codec::Primitive::from_json_parts(
                value, element, path,
            )?)),
            "Address" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Address(Box::new(inner)))
            }
            "Age" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Age(Box::new(inner)))
            }
            "Annotation" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Annotation(Box::new(inner)))
            }
            "Attachment" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Attachment(Box::new(inner)))
            }
            "CodeableConcept" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::CodeableConcept(Box::new(inner)))
            }
            "Coding" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Coding(Box::new(inner)))
            }
            "ContactPoint" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::ContactPoint(Box::new(inner)))
            }
            "Count" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Count(Box::new(inner)))
            }
            "Distance" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Distance(Box::new(inner)))
            }
            "Duration" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Duration(Box::new(inner)))
            }
            "HumanName" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::HumanName(Box::new(inner)))
            }
            "Identifier" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Identifier(Box::new(inner)))
            }
            "Money" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Money(Box::new(inner)))
            }
            "Period" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Period(Box::new(inner)))
            }
            "Quantity" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Quantity(Box::new(inner)))
            }
            "Range" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Range(Box::new(inner)))
            }
            "Ratio" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Ratio(Box::new(inner)))
            }
            "Reference" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Reference(Box::new(inner)))
            }
            "SampledData" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::SampledData(Box::new(inner)))
            }
            "Signature" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Signature(Box::new(inner)))
            }
            "Timing" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Timing(Box::new(inner)))
            }
            "Meta" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Meta(Box::new(inner)))
            }
            _ => Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty)),
        }
    }
}

/// Content to create because of this mapping rule.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct StructureMapGroupRuleTarget {
    /// 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>,
    /// Type or variable this rule applies to.
    pub context: Option<super::primitives::Id>,
    /// type | variable
    ///
    /// How to interpret the context.
    pub context_type: Option<super::primitives::Code>,
    /// Field to create in the context.
    pub element: Option<super::primitives::String>,
    /// Named context for field, if desired, and a field is specified.
    pub variable: Option<super::primitives::Id>,
    /// first | share | last | collate
    ///
    /// If field is a list, how to manage the list.
    pub list_mode: Vec<super::primitives::Code>,
    /// Internal rule reference for shared list items.
    pub list_rule_id: Option<super::primitives::Id>,
    /// create | copy +
    ///
    /// How the data is copied / created.
    pub transform: Option<super::primitives::Code>,
    /// Parameters to the transform.
    pub parameter: Vec<StructureMapGroupRuleTargetParameter>,
}

impl super::super::codec::Json for StructureMapGroupRuleTarget {
    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.context {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("context"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_context"), e);
            }
        }
        if let Some(item) = &self.context_type {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("contextType"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_contextType"), e);
            }
        }
        if let Some(item) = &self.element {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("element"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_element"), e);
            }
        }
        if let Some(item) = &self.variable {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("variable"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_variable"), e);
            }
        }
        if !self.list_mode.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.list_mode)?;
            object.insert(std::string::String::from("listMode"), values);
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_listMode"), elements);
            }
        }
        if let Some(item) = &self.list_rule_id {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("listRuleId"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_listRuleId"), e);
            }
        }
        if let Some(item) = &self.transform {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("transform"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_transform"), e);
            }
        }
        if !self.parameter.is_empty() {
            let mut items = Vec::with_capacity(self.parameter.len());
            for item in &self.parameter {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("parameter"),
                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_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_context: Option<&super::super::codec::Value> = None;
        let mut raw_context_element: Option<&super::super::codec::Value> = None;
        let mut raw_context_type: Option<&super::super::codec::Value> = None;
        let mut raw_context_type_element: Option<&super::super::codec::Value> = None;
        let mut raw_element: Option<&super::super::codec::Value> = None;
        let mut raw_element_element: Option<&super::super::codec::Value> = None;
        let mut raw_variable: Option<&super::super::codec::Value> = None;
        let mut raw_variable_element: Option<&super::super::codec::Value> = None;
        let mut raw_list_mode: Option<&super::super::codec::Value> = None;
        let mut raw_list_mode_element: Option<&super::super::codec::Value> = None;
        let mut raw_list_rule_id: Option<&super::super::codec::Value> = None;
        let mut raw_list_rule_id_element: Option<&super::super::codec::Value> = None;
        let mut raw_transform: Option<&super::super::codec::Value> = None;
        let mut raw_transform_element: Option<&super::super::codec::Value> = None;
        let mut raw_parameter: 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);
                }
                "context" => {
                    raw_context = Some(value);
                }
                "_context" => {
                    raw_context_element = Some(value);
                }
                "contextType" => {
                    raw_context_type = Some(value);
                }
                "_contextType" => {
                    raw_context_type_element = Some(value);
                }
                "element" => {
                    raw_element = Some(value);
                }
                "_element" => {
                    raw_element_element = Some(value);
                }
                "variable" => {
                    raw_variable = Some(value);
                }
                "_variable" => {
                    raw_variable_element = Some(value);
                }
                "listMode" => {
                    raw_list_mode = Some(value);
                }
                "_listMode" => {
                    raw_list_mode_element = Some(value);
                }
                "listRuleId" => {
                    raw_list_rule_id = Some(value);
                }
                "_listRuleId" => {
                    raw_list_rule_id_element = Some(value);
                }
                "transform" => {
                    raw_transform = Some(value);
                }
                "_transform" => {
                    raw_transform_element = Some(value);
                }
                "parameter" => {
                    raw_parameter = 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_context = match (raw_context, raw_context_element) {
            (None, None) => None,
            (value, element) => Some(path.with("context", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_context_type = match (raw_context_type, raw_context_type_element) {
            (None, None) => None,
            (value, element) => Some(path.with("contextType", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_element = match (raw_element, raw_element_element) {
            (None, None) => None,
            (value, element) => Some(path.with("element", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_variable = match (raw_variable, raw_variable_element) {
            (None, None) => None,
            (value, element) => Some(path.with("variable", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_list_mode = Vec::new();
        for (index, (value, element)) in
            super::super::codec::pair_arrays(raw_list_mode, raw_list_mode_element, path)?
                .into_iter()
                .enumerate()
        {
            field_list_mode.push(path.with_index("listMode", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let field_list_rule_id = match (raw_list_rule_id, raw_list_rule_id_element) {
            (None, None) => None,
            (value, element) => Some(path.with("listRuleId", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_transform = match (raw_transform, raw_transform_element) {
            (None, None) => None,
            (value, element) => Some(path.with("transform", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_parameter = Vec::new();
        if let Some(raw) = raw_parameter {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_parameter.push(path.with_index("parameter", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            context: field_context,
            context_type: field_context_type,
            element: field_element,
            variable: field_variable,
            list_mode: field_list_mode,
            list_rule_id: field_list_rule_id,
            transform: field_transform,
            parameter: field_parameter,
        })
    }
}

impl serde::Serialize for StructureMapGroupRuleTarget {
    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.context {
            super::super::codec::element_entry(&mut map, "_context", item)?;
        }
        if let Some(item) = &self.context_type {
            super::super::codec::element_entry(&mut map, "_contextType", item)?;
        }
        if let Some(item) = &self.element {
            super::super::codec::element_entry(&mut map, "_element", item)?;
        }
        super::super::codec::element_list_entry(&mut map, "_listMode", &self.list_mode)?;
        if let Some(item) = &self.list_rule_id {
            super::super::codec::element_entry(&mut map, "_listRuleId", item)?;
        }
        if let Some(item) = &self.transform {
            super::super::codec::element_entry(&mut map, "_transform", item)?;
        }
        if let Some(item) = &self.variable {
            super::super::codec::element_entry(&mut map, "_variable", item)?;
        }
        if let Some(item) = &self.context {
            super::super::codec::value_entry(&mut map, "context", item)?;
        }
        if let Some(item) = &self.context_type {
            super::super::codec::value_entry(&mut map, "contextType", item)?;
        }
        if let Some(item) = &self.element {
            super::super::codec::value_entry(&mut map, "element", 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)?;
        }
        super::super::codec::value_list_entry(&mut map, "listMode", &self.list_mode)?;
        if let Some(item) = &self.list_rule_id {
            super::super::codec::value_entry(&mut map, "listRuleId", item)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if !self.parameter.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "parameter", &self.parameter)?;
        }
        if let Some(item) = &self.transform {
            super::super::codec::value_entry(&mut map, "transform", item)?;
        }
        if let Some(item) = &self.variable {
            super::super::codec::value_entry(&mut map, "variable", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for StructureMapGroupRuleTarget {
    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("StructureMapGroupRuleTarget");
        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)
    }
}

/// Parameters to the transform.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StructureMapGroupRuleTargetParameter {
    /// 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>,
    /// Parameter value - variable or literal.
    pub value: StructureMapGroupRuleTargetParameterValue,
}

impl super::super::codec::Json for StructureMapGroupRuleTargetParameter {
    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),
            );
        }
        let (suffix, value, element) = self.value.to_json_parts()?;
        if let Some(value) = value {
            object.insert(format!("value{suffix}"), value);
        }
        if let Some(element) = element {
            object.insert(format!("_value{suffix}"), element);
        }
        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_value = super::super::codec::ChoiceSlot::default();
        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);
                }
                "valueId" => {
                    raw_value.value("Id", value, path)?;
                }
                "_valueId" => {
                    raw_value.element("Id", value, path)?;
                }
                "valueString" => {
                    raw_value.value("String", value, path)?;
                }
                "_valueString" => {
                    raw_value.element("String", value, path)?;
                }
                "valueBoolean" => {
                    raw_value.value("Boolean", value, path)?;
                }
                "_valueBoolean" => {
                    raw_value.element("Boolean", value, path)?;
                }
                "valueInteger" => {
                    raw_value.value("Integer", value, path)?;
                }
                "_valueInteger" => {
                    raw_value.element("Integer", value, path)?;
                }
                "valueDecimal" => {
                    raw_value.value("Decimal", value, path)?;
                }
                "_valueDecimal" => {
                    raw_value.element("Decimal", value, path)?;
                }
                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_value = path.with("value", |path| {
            let suffix = raw_value
                .suffix
                .ok_or_else(|| path.error(super::super::codec::DecodeErrorKind::MissingProperty))?;
            StructureMapGroupRuleTargetParameterValue::from_json_parts(
                suffix,
                raw_value.value,
                raw_value.element,
                path,
            )
        })?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            value: field_value,
        })
    }
}

impl serde::Serialize for StructureMapGroupRuleTargetParameter {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        match &self.value {
            StructureMapGroupRuleTargetParameterValue::Boolean(inner) => {
                super::super::codec::element_entry(&mut map, "_valueBoolean", inner)?;
            }
            StructureMapGroupRuleTargetParameterValue::Decimal(inner) => {
                super::super::codec::element_entry(&mut map, "_valueDecimal", inner)?;
            }
            StructureMapGroupRuleTargetParameterValue::Id(inner) => {
                super::super::codec::element_entry(&mut map, "_valueId", inner)?;
            }
            StructureMapGroupRuleTargetParameterValue::Integer(inner) => {
                super::super::codec::element_entry(&mut map, "_valueInteger", inner)?;
            }
            StructureMapGroupRuleTargetParameterValue::String(inner) => {
                super::super::codec::element_entry(&mut map, "_valueString", inner)?;
            }
        }
        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,
            )?;
        }
        match &self.value {
            StructureMapGroupRuleTargetParameterValue::Boolean(inner) => {
                super::super::codec::value_entry(&mut map, "valueBoolean", inner)?;
            }
            StructureMapGroupRuleTargetParameterValue::Decimal(inner) => {
                super::super::codec::value_entry(&mut map, "valueDecimal", inner)?;
            }
            StructureMapGroupRuleTargetParameterValue::Id(inner) => {
                super::super::codec::value_entry(&mut map, "valueId", inner)?;
            }
            StructureMapGroupRuleTargetParameterValue::Integer(inner) => {
                super::super::codec::value_entry(&mut map, "valueInteger", inner)?;
            }
            StructureMapGroupRuleTargetParameterValue::String(inner) => {
                super::super::codec::value_entry(&mut map, "valueString", inner)?;
            }
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for StructureMapGroupRuleTargetParameter {
    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("StructureMapGroupRuleTargetParameter");
        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)
    }
}

/// The \`value\[x\]\` choice of \`StructureMapGroupRuleTargetParameter\`.
///
/// Parameter value - variable or literal.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum StructureMapGroupRuleTargetParameterValue {
    /// The `id` form.
    Id(super::primitives::Id),
    /// The `string` form.
    String(super::primitives::String),
    /// The `boolean` form.
    Boolean(super::primitives::Boolean),
    /// The `integer` form.
    Integer(super::primitives::Integer),
    /// The `decimal` form.
    Decimal(super::primitives::Decimal),
}

impl StructureMapGroupRuleTargetParameterValue {
    /// The key suffix, the value part, and the `_name` part of this form.
    ///
    /// # Errors
    ///
    /// Returns [`super::super::codec::EncodeError`] when a held value has no JSON form.
    pub fn to_json_parts(
        &self,
    ) -> Result<
        (
            &'static str,
            Option<super::super::codec::Value>,
            Option<super::super::codec::Value>,
        ),
        super::super::codec::EncodeError,
    > {
        match self {
            Self::Id(inner) => Ok((
                "Id",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::String(inner) => Ok((
                "String",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Boolean(inner) => Ok((
                "Boolean",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Integer(inner) => Ok((
                "Integer",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Decimal(inner) => Ok((
                "Decimal",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
        }
    }

    /// Decodes the form named by `suffix` from its value and `_name` parts.
    ///
    /// # Errors
    ///
    /// Returns [`super::super::codec::DecodeError`] for an unknown suffix or a malformed part.
    pub fn from_json_parts(
        suffix: &str,
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        match suffix {
            "Id" => Ok(Self::Id(super::super::codec::Primitive::from_json_parts(
                value, element, path,
            )?)),
            "String" => Ok(Self::String(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Boolean" => Ok(Self::Boolean(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Integer" => Ok(Self::Integer(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Decimal" => Ok(Self::Decimal(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            _ => Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty)),
        }
    }
}

/// Structure Definition used by this map
///
/// A structure definition used by this map. The structure definition may
/// describe instances that are converted, or the instances that are produced.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct StructureMapStructure {
    /// 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>,
    /// Canonical URL for structure definition
    ///
    /// The canonical URL that identifies the structure.
    pub url: super::primitives::Uri,
    /// source | queried | target | produced
    ///
    /// How the referenced structure is used in this mapping.
    pub mode: super::primitives::Code,
    /// Name for type in this map
    ///
    /// The name used for this type in the map.
    pub alias: Option<super::primitives::String>,
    /// Documentation on use of structure
    ///
    /// Documentation that describes how the structure is used in the mapping.
    pub documentation: Option<super::primitives::String>,
}

impl super::super::codec::Json for StructureMapStructure {
    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.url)? {
            object.insert(std::string::String::from("url"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.url)? {
            object.insert(std::string::String::from("_url"), e);
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.mode)? {
            object.insert(std::string::String::from("mode"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.mode)? {
            object.insert(std::string::String::from("_mode"), e);
        }
        if let Some(item) = &self.alias {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("alias"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_alias"), e);
            }
        }
        if let Some(item) = &self.documentation {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("documentation"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_documentation"), 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_url: Option<&super::super::codec::Value> = None;
        let mut raw_url_element: Option<&super::super::codec::Value> = None;
        let mut raw_mode: Option<&super::super::codec::Value> = None;
        let mut raw_mode_element: Option<&super::super::codec::Value> = None;
        let mut raw_alias: Option<&super::super::codec::Value> = None;
        let mut raw_alias_element: Option<&super::super::codec::Value> = None;
        let mut raw_documentation: Option<&super::super::codec::Value> = None;
        let mut raw_documentation_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);
                }
                "url" => {
                    raw_url = Some(value);
                }
                "_url" => {
                    raw_url_element = Some(value);
                }
                "mode" => {
                    raw_mode = Some(value);
                }
                "_mode" => {
                    raw_mode_element = Some(value);
                }
                "alias" => {
                    raw_alias = Some(value);
                }
                "_alias" => {
                    raw_alias_element = Some(value);
                }
                "documentation" => {
                    raw_documentation = Some(value);
                }
                "_documentation" => {
                    raw_documentation_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_url = path.with("url", |path| {
            super::super::codec::Primitive::from_json_parts(raw_url, raw_url_element, path)
        })?;
        let field_mode = path.with("mode", |path| {
            super::super::codec::Primitive::from_json_parts(raw_mode, raw_mode_element, path)
        })?;
        let field_alias = match (raw_alias, raw_alias_element) {
            (None, None) => None,
            (value, element) => Some(path.with("alias", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_documentation = match (raw_documentation, raw_documentation_element) {
            (None, None) => None,
            (value, element) => Some(path.with("documentation", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            url: field_url,
            mode: field_mode,
            alias: field_alias,
            documentation: field_documentation,
        })
    }
}

impl serde::Serialize for StructureMapStructure {
    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.alias {
            super::super::codec::element_entry(&mut map, "_alias", item)?;
        }
        if let Some(item) = &self.documentation {
            super::super::codec::element_entry(&mut map, "_documentation", item)?;
        }
        super::super::codec::element_entry(&mut map, "_mode", &self.mode)?;
        super::super::codec::element_entry(&mut map, "_url", &self.url)?;
        if let Some(item) = &self.alias {
            super::super::codec::value_entry(&mut map, "alias", item)?;
        }
        if let Some(item) = &self.documentation {
            super::super::codec::value_entry(&mut map, "documentation", 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)?;
        }
        super::super::codec::value_entry(&mut map, "mode", &self.mode)?;
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        super::super::codec::value_entry(&mut map, "url", &self.url)?;
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for StructureMapStructure {
    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("StructureMapStructure");
        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)
    }
}