fhir-types 0.1.115

// @generated by fhir-codegen from hl7.fhir.r6.core 6.0.0-ballot5. DO NOT EDIT.
// Change the emitter (tools/fhir-codegen) and regenerate.
// SPDX-FileCopyrightText: Cadasto B.V.
// SPDX-License-Identifier: Apache-2.0
//! Definition of an element in a resource or extension

/// Definition of an element in a resource or extension
///
/// Captures constraints on each element within the resource, profile, or
/// extension.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct ElementDefinition {
    /// Unique id for inter-element referencing
    ///
    /// 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. To make the use of extensions safe and
    /// managable, there is a strict set of governance applied to the definition and
    /// use of extensions. Though any implementer can 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 even if unrecognized
    ///
    /// 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 in which it is contained and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and managable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer can 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. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// Path of the element in the hierarchy of elements
    ///
    /// The path identifies the element and is expressed as a "."-separated list of
    /// ancestor elements, beginning with the name of the resource or extension.
    pub path: super::primitives::String,
    /// xmlAttr | xmlText | typeAttr | cdaText | xhtml
    ///
    /// Codes that define how this element is represented in instances, when the
    /// deviation varies from the normal case. No extensions are allowed on elements
    /// with a representation of 'xmlAttr', no matter what FHIR serialization format
    /// is used.
    pub representation: Vec<super::primitives::Code>,
    /// Name for this particular element (in a set of slices)
    ///
    /// The name of this element definition slice, when slicing is working. The name
    /// must be a token with no dots or spaces. This is a unique name referring to a
    /// specific set of constraints applied to this element, used to provide a name
    /// to different slices of the same element.
    pub slice_name: Option<super::primitives::String>,
    /// If this slice definition constrains an inherited slice definition (or not)
    ///
    /// If true, indicates that this slice definition is constraining a slice
    /// definition with the same name in an inherited profile. If false, the slice
    /// is not overriding any slice in an inherited profile. If missing, the slice
    /// might or might not be overriding a slice in an inherited profile, depending
    /// on the sliceName.
    pub slice_is_constraining: Option<super::primitives::Boolean>,
    /// String to display with or prompt for element
    ///
    /// A single preferred label which is the text to display beside the element
    /// indicating its meaning or to use to prompt for the element in a user display
    /// or form.
    pub label: Option<super::primitives::String>,
    /// Corresponding codes in terminologies
    ///
    /// A code that has the same meaning as the element in a particular terminology.
    pub code: Vec<super::coding::Coding>,
    /// This element is sliced - slices follow
    ///
    /// Indicates that the element is sliced into a set of alternative definitions
    /// (i.e. in a structure definition, there are multiple different constraints on
    /// a single element in the base resource). Slicing can be used in any resource
    /// that has cardinality ..\* on the base resource, or any resource with a
    /// choice of types. The set of slices is any elements that come after this in
    /// the element sequence that have the same path, until a shorter path occurs
    /// (the shorter path terminates the set).
    pub slicing: Option<ElementDefinitionSlicing>,
    /// Concise definition for space-constrained presentation
    ///
    /// A concise description of what this element means (e.g. for use in
    /// autogenerated summaries).
    pub short: Option<super::primitives::String>,
    /// Full formal definition as narrative text
    ///
    /// Provides a complete explanation of the meaning of the data element for human
    /// readability. For the case of elements derived from existing elements (e.g.
    /// constraints), the definition SHALL be consistent with the base definition,
    /// but convey the meaning of the element in the particular context of use of
    /// the resource. (Note: The text you are reading is specified in
    /// ElementDefinition.definition).
    pub definition: Option<super::primitives::Markdown>,
    /// Comments about the use of this element
    ///
    /// Explanatory notes and implementation guidance about the data element,
    /// including notes about how to use the data properly, exceptions to proper
    /// use, etc. (Note: The text you are reading is specified in
    /// ElementDefinition.comment).
    pub comment: Option<super::primitives::Markdown>,
    /// Requirements satisfied by this element/structure and its constraints
    ///
    /// This element is for traceability of why the element was created and why the
    /// constraints exist as they do. This may be used to point to source materials
    /// or specifications that drove the structure of this element.
    pub requirements: Option<super::primitives::Markdown>,
    /// Other names
    ///
    /// Identifies additional names by which this element might also be known.
    pub alias: Vec<super::primitives::String>,
    /// Minimum Cardinality
    ///
    /// The minimum number of times this element SHALL appear in the instance.
    pub min: Option<super::primitives::UnsignedInt>,
    /// Maximum Cardinality (a number or \*)
    ///
    /// The maximum number of times this element is permitted to appear in the
    /// instance.
    pub max: Option<super::primitives::String>,
    /// Base definition information for tools
    ///
    /// Information about the base definition of the element, provided to make it
    /// unnecessary for tools to trace the deviation of the element through the
    /// derived and related profiles. When the element definition is not the
    /// original definition of an element - e.g. either in a constraint on another
    /// type, or for elements from a super type in a snap shot - then the
    /// information in provided in the element definition may be different to the
    /// base definition. On the original definition of the element, it will be same.
    pub base: Option<ElementDefinitionBase>,
    /// Reference to definition of content for the element
    ///
    /// Identifies an element defined elsewhere in the definition whose content
    /// rules should be applied to the current element. ContentReferences bring
    /// across all the rules that are in the ElementDefinition for the element,
    /// including definitions, cardinality constraints, bindings, invariants etc.
    pub content_reference: Option<super::primitives::Uri>,
    /// Data type and Profile for this element
    ///
    /// The data type or resource that the value of this element is permitted to be.
    pub r#type: Vec<ElementDefinitionType>,
    /// Specified value if missing from instance
    ///
    /// The value that should be used if there is no value stated in the instance
    /// (e.g. 'if not otherwise specified, the abstract is false').
    pub default_value: Option<ElementDefinitionDefaultValue>,
    /// Implicit meaning when this element is missing
    ///
    /// The Implicit meaning that is to be understood when this element is missing
    /// (e.g. 'when this element is missing, the period is ongoing').
    pub meaning_when_missing: Option<super::primitives::Markdown>,
    /// What the order of the elements means
    ///
    /// If present, indicates that the order of the repeating element has meaning
    /// and describes what that meaning is. If absent, it means that the order of
    /// the element has no meaning.
    pub order_meaning: Option<super::primitives::String>,
    /// Value must be exactly this
    ///
    /// Specifies a value that SHALL be exactly the value for this element in the
    /// instance, if present. For purposes of comparison, non-significant whitespace
    /// is ignored, and all values must be an exact match (case and accent
    /// sensitive). Missing elements/attributes must also be missing.
    pub fixed: Option<ElementDefinitionFixed>,
    /// Value must have at least these property values
    ///
    /// Specifies a value that each occurrence of the element in the instance SHALL
    /// follow - that is, any value in the pattern must be found in the instance, if
    /// the element has a value. Other additional values may be found too. This is
    /// effectively constraint by example. When pattern\[x\] is used to constrain a
    /// primitive, it means that the value provided in the pattern\[x\] must match
    /// the instance value exactly. When an element within a pattern\[x\] is used to
    /// constrain an array, it means that each element provided in the pattern\[x\]
    /// must (recursively) match at least one element from the instance array. When
    /// pattern\[x\] is used to constrain a complex object, it means that each
    /// property in the pattern must be present in the complex object, and its value
    /// must recursively match -- i.e., 1. If primitive: it must match exactly the
    /// pattern value 2. If a complex object: it must match (recursively) the
    /// pattern value 3. If an array: it must match (recursively) the pattern value
    /// If a pattern\[x\] is declared on a repeating element, the pattern applies to
    /// all repetitions. If the desire is for a pattern to apply to only one element
    /// or a subset of elements, slicing must be used. See \[Examples of
    /// Patterns\](elementdefinition-examples.html\#pattern-examples) for examples
    /// of pattern usage and the effect it will have.
    pub pattern: Option<ElementDefinitionPattern>,
    /// Example value (as defined for type)
    ///
    /// A sample value for this element demonstrating the type of information that
    /// would typically be found in the element.
    pub example: Vec<ElementDefinitionExample>,
    /// Minimum Allowed Value (for some types)
    ///
    /// The minimum allowed value for the element. The value is inclusive. This is
    /// allowed for the types date, dateTime, instant, time, decimal, integer, and
    /// Quantity.
    pub min_value: Option<ElementDefinitionMinValue>,
    /// Maximum Allowed Value (for some types)
    ///
    /// The maximum allowed value for the element. The value is inclusive. This is
    /// allowed for the types date, dateTime, instant, time, decimal, integer, and
    /// Quantity.
    pub max_value: Option<ElementDefinitionMaxValue>,
    /// Max length for string type data
    ///
    /// Indicates the maximum length in characters that is permitted to be present
    /// in conformant instances and which is expected to be supported by conformant
    /// consumers that support the element. \`\`\`maxLength\`\`\` SHOULD only be
    /// used on primitive data types that have a have a length (see \[Tupe
    /// Characteristics\](datatypes.html\#other) and \[Structure Type Characterstics
    /// (Constraint
    /// Control)\](<https://build.fhir.org/ig/HL7/fhir-extensions/StructureDefinition-structuredefinition-type-characteristics.html>)).
    pub max_length: Option<super::primitives::Integer>,
    /// Reference to invariant about presence
    ///
    /// A reference to an invariant that may make additional statements about the
    /// cardinality or value in the instance.
    pub condition: Vec<super::primitives::Id>,
    /// Condition that must evaluate to true
    ///
    /// Formal constraints such as co-occurrence and other constraints that can be
    /// computationally evaluated within the context of the instance.
    pub constraint: Vec<ElementDefinitionConstraint>,
    /// For primitives, that a value must be present - not replaced by an extension
    ///
    /// Specifies for a primitive data type that the value of the data type cannot
    /// be replaced by an extension.
    pub must_have_value: Option<super::primitives::Boolean>,
    /// Extensions that are allowed to replace the value or content
    ///
    /// Specifies a list of extensions that can appear in place of a value (for
    /// primitive types) or non-extension child elements (for complex types and
    /// backbone elements).
    pub value_alternatives: Vec<super::primitives::Canonical>,
    /// If the element must be supported (discouraged - see obligations)
    ///
    /// If true, implementations that produce or consume resources SHALL provide
    /// "support" for the element in some meaningful way. Note that this is being
    /// phased out and replaced by obligations (see below). If false, the element
    /// may be ignored and not supported. If false, whether to populate or use the
    /// data element in any way is at the discretion of the implementation.
    pub must_support: Option<super::primitives::Boolean>,
    /// If this modifies the meaning of other elements
    ///
    /// If true, the value of this element affects the interpretation of the element
    /// or resource that contains it, and the value of the element cannot be
    /// ignored. Typically, this is used for status, negation and qualification
    /// codes. The effect of this is that the element cannot be ignored by systems:
    /// they SHALL either recognize the element and process it, and/or a
    /// pre-determination has been made that it is not relevant to their particular
    /// system. When used on the root element in an extension definition, this
    /// indicates whether or not the extension is a modifier extension.
    pub is_modifier: Option<super::primitives::Boolean>,
    /// Reason that this element is marked as a modifier
    ///
    /// Explains how that element affects the interpretation of the resource or
    /// element that contains it.
    pub is_modifier_reason: Option<super::primitives::String>,
    /// Include when \_summary = true?
    ///
    /// Whether the element should be included if a client requests a search with
    /// the parameter \_summary=true.
    pub is_summary: Option<super::primitives::Boolean>,
    /// ValueSet details if this is coded
    ///
    /// Binds to a value set if this element is coded (code, Coding,
    /// CodeableConcept, Quantity), or the data types (string, uri).
    pub binding: Option<ElementDefinitionBinding>,
    /// Map element to another set of definitions
    ///
    /// Identifies a concept from an external specification that roughly corresponds
    /// to this element.
    pub mapping: Vec<ElementDefinitionMapping>,
}

impl super::super::codec::Json for ElementDefinition {
    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.path)? {
            object.insert(std::string::String::from("path"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.path)? {
            object.insert(std::string::String::from("_path"), e);
        }
        if !self.representation.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.representation)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("representation"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_representation"), elements);
            }
        }
        if let Some(item) = &self.slice_name {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("sliceName"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_sliceName"), e);
            }
        }
        if let Some(item) = &self.slice_is_constraining {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("sliceIsConstraining"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_sliceIsConstraining"), e);
            }
        }
        if let Some(item) = &self.label {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("label"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_label"), e);
            }
        }
        if !self.code.is_empty() {
            let mut items = Vec::with_capacity(self.code.len());
            for item in &self.code {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("code"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.slicing {
            object.insert(
                std::string::String::from("slicing"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.short {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("short"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_short"), e);
            }
        }
        if let Some(item) = &self.definition {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("definition"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_definition"), e);
            }
        }
        if let Some(item) = &self.comment {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("comment"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_comment"), e);
            }
        }
        if let Some(item) = &self.requirements {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("requirements"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_requirements"), e);
            }
        }
        if !self.alias.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.alias)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("alias"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_alias"), elements);
            }
        }
        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.base {
            object.insert(
                std::string::String::from("base"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.content_reference {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("contentReference"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_contentReference"), e);
            }
        }
        if !self.r#type.is_empty() {
            let mut items = Vec::with_capacity(self.r#type.len());
            for item in &self.r#type {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("type"),
                super::super::codec::Value::Array(items),
            );
        }
        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.meaning_when_missing {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("meaningWhenMissing"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_meaningWhenMissing"), e);
            }
        }
        if let Some(item) = &self.order_meaning {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("orderMeaning"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_orderMeaning"), e);
            }
        }
        if let Some(item) = &self.fixed {
            let (suffix, value, element) = item.to_json_parts()?;
            if let Some(value) = value {
                object.insert(format!("fixed{suffix}"), value);
            }
            if let Some(element) = element {
                object.insert(format!("_fixed{suffix}"), element);
            }
        }
        if let Some(item) = &self.pattern {
            let (suffix, value, element) = item.to_json_parts()?;
            if let Some(value) = value {
                object.insert(format!("pattern{suffix}"), value);
            }
            if let Some(element) = element {
                object.insert(format!("_pattern{suffix}"), element);
            }
        }
        if !self.example.is_empty() {
            let mut items = Vec::with_capacity(self.example.len());
            for item in &self.example {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("example"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.min_value {
            let (suffix, value, element) = item.to_json_parts()?;
            if let Some(value) = value {
                object.insert(format!("minValue{suffix}"), value);
            }
            if let Some(element) = element {
                object.insert(format!("_minValue{suffix}"), element);
            }
        }
        if let Some(item) = &self.max_value {
            let (suffix, value, element) = item.to_json_parts()?;
            if let Some(value) = value {
                object.insert(format!("maxValue{suffix}"), value);
            }
            if let Some(element) = element {
                object.insert(format!("_maxValue{suffix}"), element);
            }
        }
        if let Some(item) = &self.max_length {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("maxLength"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_maxLength"), e);
            }
        }
        if !self.condition.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.condition)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("condition"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_condition"), elements);
            }
        }
        if !self.constraint.is_empty() {
            let mut items = Vec::with_capacity(self.constraint.len());
            for item in &self.constraint {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("constraint"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.must_have_value {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("mustHaveValue"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_mustHaveValue"), e);
            }
        }
        if !self.value_alternatives.is_empty() {
            let (values, elements) =
                super::super::codec::primitive_arrays(&self.value_alternatives)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("valueAlternatives"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_valueAlternatives"), elements);
            }
        }
        if let Some(item) = &self.must_support {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("mustSupport"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_mustSupport"), e);
            }
        }
        if let Some(item) = &self.is_modifier {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("isModifier"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_isModifier"), e);
            }
        }
        if let Some(item) = &self.is_modifier_reason {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("isModifierReason"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_isModifierReason"), e);
            }
        }
        if let Some(item) = &self.is_summary {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("isSummary"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_isSummary"), e);
            }
        }
        if let Some(item) = &self.binding {
            object.insert(
                std::string::String::from("binding"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if !self.mapping.is_empty() {
            let mut items = Vec::with_capacity(self.mapping.len());
            for item in &self.mapping {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("mapping"),
                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_path: Option<&super::super::codec::Value> = None;
        let mut raw_path_element: Option<&super::super::codec::Value> = None;
        let mut raw_representation: Option<&super::super::codec::Value> = None;
        let mut raw_representation_element: Option<&super::super::codec::Value> = None;
        let mut raw_slice_name: Option<&super::super::codec::Value> = None;
        let mut raw_slice_name_element: Option<&super::super::codec::Value> = None;
        let mut raw_slice_is_constraining: Option<&super::super::codec::Value> = None;
        let mut raw_slice_is_constraining_element: Option<&super::super::codec::Value> = None;
        let mut raw_label: Option<&super::super::codec::Value> = None;
        let mut raw_label_element: Option<&super::super::codec::Value> = None;
        let mut raw_code: Option<&super::super::codec::Value> = None;
        let mut raw_slicing: Option<&super::super::codec::Value> = None;
        let mut raw_short: Option<&super::super::codec::Value> = None;
        let mut raw_short_element: Option<&super::super::codec::Value> = None;
        let mut raw_definition: Option<&super::super::codec::Value> = None;
        let mut raw_definition_element: Option<&super::super::codec::Value> = None;
        let mut raw_comment: Option<&super::super::codec::Value> = None;
        let mut raw_comment_element: Option<&super::super::codec::Value> = None;
        let mut raw_requirements: Option<&super::super::codec::Value> = None;
        let mut raw_requirements_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_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_base: Option<&super::super::codec::Value> = None;
        let mut raw_content_reference: Option<&super::super::codec::Value> = None;
        let mut raw_content_reference_element: Option<&super::super::codec::Value> = None;
        let mut raw_type: Option<&super::super::codec::Value> = None;
        let mut raw_default_value = super::super::codec::ChoiceSlot::default();
        let mut raw_meaning_when_missing: Option<&super::super::codec::Value> = None;
        let mut raw_meaning_when_missing_element: Option<&super::super::codec::Value> = None;
        let mut raw_order_meaning: Option<&super::super::codec::Value> = None;
        let mut raw_order_meaning_element: Option<&super::super::codec::Value> = None;
        let mut raw_fixed = super::super::codec::ChoiceSlot::default();
        let mut raw_pattern = super::super::codec::ChoiceSlot::default();
        let mut raw_example: Option<&super::super::codec::Value> = None;
        let mut raw_min_value = super::super::codec::ChoiceSlot::default();
        let mut raw_max_value = super::super::codec::ChoiceSlot::default();
        let mut raw_max_length: Option<&super::super::codec::Value> = None;
        let mut raw_max_length_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_constraint: Option<&super::super::codec::Value> = None;
        let mut raw_must_have_value: Option<&super::super::codec::Value> = None;
        let mut raw_must_have_value_element: Option<&super::super::codec::Value> = None;
        let mut raw_value_alternatives: Option<&super::super::codec::Value> = None;
        let mut raw_value_alternatives_element: Option<&super::super::codec::Value> = None;
        let mut raw_must_support: Option<&super::super::codec::Value> = None;
        let mut raw_must_support_element: Option<&super::super::codec::Value> = None;
        let mut raw_is_modifier: Option<&super::super::codec::Value> = None;
        let mut raw_is_modifier_element: Option<&super::super::codec::Value> = None;
        let mut raw_is_modifier_reason: Option<&super::super::codec::Value> = None;
        let mut raw_is_modifier_reason_element: Option<&super::super::codec::Value> = None;
        let mut raw_is_summary: Option<&super::super::codec::Value> = None;
        let mut raw_is_summary_element: Option<&super::super::codec::Value> = None;
        let mut raw_binding: Option<&super::super::codec::Value> = None;
        let mut raw_mapping: 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);
                }
                "path" => {
                    raw_path = Some(value);
                }
                "_path" => {
                    raw_path_element = Some(value);
                }
                "representation" => {
                    raw_representation = Some(value);
                }
                "_representation" => {
                    raw_representation_element = Some(value);
                }
                "sliceName" => {
                    raw_slice_name = Some(value);
                }
                "_sliceName" => {
                    raw_slice_name_element = Some(value);
                }
                "sliceIsConstraining" => {
                    raw_slice_is_constraining = Some(value);
                }
                "_sliceIsConstraining" => {
                    raw_slice_is_constraining_element = Some(value);
                }
                "label" => {
                    raw_label = Some(value);
                }
                "_label" => {
                    raw_label_element = Some(value);
                }
                "code" => {
                    raw_code = Some(value);
                }
                "slicing" => {
                    raw_slicing = Some(value);
                }
                "short" => {
                    raw_short = Some(value);
                }
                "_short" => {
                    raw_short_element = Some(value);
                }
                "definition" => {
                    raw_definition = Some(value);
                }
                "_definition" => {
                    raw_definition_element = Some(value);
                }
                "comment" => {
                    raw_comment = Some(value);
                }
                "_comment" => {
                    raw_comment_element = Some(value);
                }
                "requirements" => {
                    raw_requirements = Some(value);
                }
                "_requirements" => {
                    raw_requirements_element = Some(value);
                }
                "alias" => {
                    raw_alias = Some(value);
                }
                "_alias" => {
                    raw_alias_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);
                }
                "base" => {
                    raw_base = Some(value);
                }
                "contentReference" => {
                    raw_content_reference = Some(value);
                }
                "_contentReference" => {
                    raw_content_reference_element = Some(value);
                }
                "type" => {
                    raw_type = 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)?;
                }
                "defaultValueCanonical" => {
                    raw_default_value.value("Canonical", value, path)?;
                }
                "_defaultValueCanonical" => {
                    raw_default_value.element("Canonical", 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)?;
                }
                "defaultValueInteger64" => {
                    raw_default_value.value("Integer64", value, path)?;
                }
                "_defaultValueInteger64" => {
                    raw_default_value.element("Integer64", 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)?;
                }
                "defaultValueUrl" => {
                    raw_default_value.value("Url", value, path)?;
                }
                "_defaultValueUrl" => {
                    raw_default_value.element("Url", value, path)?;
                }
                "defaultValueUuid" => {
                    raw_default_value.value("Uuid", value, path)?;
                }
                "_defaultValueUuid" => {
                    raw_default_value.element("Uuid", 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)?;
                }
                "defaultValueCodeableReference" => {
                    raw_default_value.value("CodeableReference", value, path)?;
                }
                "_defaultValueCodeableReference" => {
                    raw_default_value.element("CodeableReference", 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)?;
                }
                "defaultValueRatioRange" => {
                    raw_default_value.value("RatioRange", value, path)?;
                }
                "_defaultValueRatioRange" => {
                    raw_default_value.element("RatioRange", 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)?;
                }
                "defaultValueContactDetail" => {
                    raw_default_value.value("ContactDetail", value, path)?;
                }
                "_defaultValueContactDetail" => {
                    raw_default_value.element("ContactDetail", value, path)?;
                }
                "defaultValueDataRequirement" => {
                    raw_default_value.value("DataRequirement", value, path)?;
                }
                "_defaultValueDataRequirement" => {
                    raw_default_value.element("DataRequirement", value, path)?;
                }
                "defaultValueExpression" => {
                    raw_default_value.value("Expression", value, path)?;
                }
                "_defaultValueExpression" => {
                    raw_default_value.element("Expression", value, path)?;
                }
                "defaultValueParameterDefinition" => {
                    raw_default_value.value("ParameterDefinition", value, path)?;
                }
                "_defaultValueParameterDefinition" => {
                    raw_default_value.element("ParameterDefinition", value, path)?;
                }
                "defaultValueRelatedArtifact" => {
                    raw_default_value.value("RelatedArtifact", value, path)?;
                }
                "_defaultValueRelatedArtifact" => {
                    raw_default_value.element("RelatedArtifact", value, path)?;
                }
                "defaultValueTriggerDefinition" => {
                    raw_default_value.value("TriggerDefinition", value, path)?;
                }
                "_defaultValueTriggerDefinition" => {
                    raw_default_value.element("TriggerDefinition", value, path)?;
                }
                "defaultValueUsageContext" => {
                    raw_default_value.value("UsageContext", value, path)?;
                }
                "_defaultValueUsageContext" => {
                    raw_default_value.element("UsageContext", value, path)?;
                }
                "defaultValueAvailability" => {
                    raw_default_value.value("Availability", value, path)?;
                }
                "_defaultValueAvailability" => {
                    raw_default_value.element("Availability", value, path)?;
                }
                "defaultValueExtendedContactDetail" => {
                    raw_default_value.value("ExtendedContactDetail", value, path)?;
                }
                "_defaultValueExtendedContactDetail" => {
                    raw_default_value.element("ExtendedContactDetail", value, path)?;
                }
                "defaultValueVirtualServiceDetail" => {
                    raw_default_value.value("VirtualServiceDetail", value, path)?;
                }
                "_defaultValueVirtualServiceDetail" => {
                    raw_default_value.element("VirtualServiceDetail", value, path)?;
                }
                "defaultValueDosage" => {
                    raw_default_value.value("Dosage", value, path)?;
                }
                "_defaultValueDosage" => {
                    raw_default_value.element("Dosage", value, path)?;
                }
                "defaultValueMeta" => {
                    raw_default_value.value("Meta", value, path)?;
                }
                "_defaultValueMeta" => {
                    raw_default_value.element("Meta", value, path)?;
                }
                "meaningWhenMissing" => {
                    raw_meaning_when_missing = Some(value);
                }
                "_meaningWhenMissing" => {
                    raw_meaning_when_missing_element = Some(value);
                }
                "orderMeaning" => {
                    raw_order_meaning = Some(value);
                }
                "_orderMeaning" => {
                    raw_order_meaning_element = Some(value);
                }
                "fixedBase64Binary" => {
                    raw_fixed.value("Base64Binary", value, path)?;
                }
                "_fixedBase64Binary" => {
                    raw_fixed.element("Base64Binary", value, path)?;
                }
                "fixedBoolean" => {
                    raw_fixed.value("Boolean", value, path)?;
                }
                "_fixedBoolean" => {
                    raw_fixed.element("Boolean", value, path)?;
                }
                "fixedCanonical" => {
                    raw_fixed.value("Canonical", value, path)?;
                }
                "_fixedCanonical" => {
                    raw_fixed.element("Canonical", value, path)?;
                }
                "fixedCode" => {
                    raw_fixed.value("Code", value, path)?;
                }
                "_fixedCode" => {
                    raw_fixed.element("Code", value, path)?;
                }
                "fixedDate" => {
                    raw_fixed.value("Date", value, path)?;
                }
                "_fixedDate" => {
                    raw_fixed.element("Date", value, path)?;
                }
                "fixedDateTime" => {
                    raw_fixed.value("DateTime", value, path)?;
                }
                "_fixedDateTime" => {
                    raw_fixed.element("DateTime", value, path)?;
                }
                "fixedDecimal" => {
                    raw_fixed.value("Decimal", value, path)?;
                }
                "_fixedDecimal" => {
                    raw_fixed.element("Decimal", value, path)?;
                }
                "fixedId" => {
                    raw_fixed.value("Id", value, path)?;
                }
                "_fixedId" => {
                    raw_fixed.element("Id", value, path)?;
                }
                "fixedInstant" => {
                    raw_fixed.value("Instant", value, path)?;
                }
                "_fixedInstant" => {
                    raw_fixed.element("Instant", value, path)?;
                }
                "fixedInteger" => {
                    raw_fixed.value("Integer", value, path)?;
                }
                "_fixedInteger" => {
                    raw_fixed.element("Integer", value, path)?;
                }
                "fixedInteger64" => {
                    raw_fixed.value("Integer64", value, path)?;
                }
                "_fixedInteger64" => {
                    raw_fixed.element("Integer64", value, path)?;
                }
                "fixedMarkdown" => {
                    raw_fixed.value("Markdown", value, path)?;
                }
                "_fixedMarkdown" => {
                    raw_fixed.element("Markdown", value, path)?;
                }
                "fixedOid" => {
                    raw_fixed.value("Oid", value, path)?;
                }
                "_fixedOid" => {
                    raw_fixed.element("Oid", value, path)?;
                }
                "fixedPositiveInt" => {
                    raw_fixed.value("PositiveInt", value, path)?;
                }
                "_fixedPositiveInt" => {
                    raw_fixed.element("PositiveInt", value, path)?;
                }
                "fixedString" => {
                    raw_fixed.value("String", value, path)?;
                }
                "_fixedString" => {
                    raw_fixed.element("String", value, path)?;
                }
                "fixedTime" => {
                    raw_fixed.value("Time", value, path)?;
                }
                "_fixedTime" => {
                    raw_fixed.element("Time", value, path)?;
                }
                "fixedUnsignedInt" => {
                    raw_fixed.value("UnsignedInt", value, path)?;
                }
                "_fixedUnsignedInt" => {
                    raw_fixed.element("UnsignedInt", value, path)?;
                }
                "fixedUri" => {
                    raw_fixed.value("Uri", value, path)?;
                }
                "_fixedUri" => {
                    raw_fixed.element("Uri", value, path)?;
                }
                "fixedUrl" => {
                    raw_fixed.value("Url", value, path)?;
                }
                "_fixedUrl" => {
                    raw_fixed.element("Url", value, path)?;
                }
                "fixedUuid" => {
                    raw_fixed.value("Uuid", value, path)?;
                }
                "_fixedUuid" => {
                    raw_fixed.element("Uuid", value, path)?;
                }
                "fixedAddress" => {
                    raw_fixed.value("Address", value, path)?;
                }
                "_fixedAddress" => {
                    raw_fixed.element("Address", value, path)?;
                }
                "fixedAge" => {
                    raw_fixed.value("Age", value, path)?;
                }
                "_fixedAge" => {
                    raw_fixed.element("Age", value, path)?;
                }
                "fixedAnnotation" => {
                    raw_fixed.value("Annotation", value, path)?;
                }
                "_fixedAnnotation" => {
                    raw_fixed.element("Annotation", value, path)?;
                }
                "fixedAttachment" => {
                    raw_fixed.value("Attachment", value, path)?;
                }
                "_fixedAttachment" => {
                    raw_fixed.element("Attachment", value, path)?;
                }
                "fixedCodeableConcept" => {
                    raw_fixed.value("CodeableConcept", value, path)?;
                }
                "_fixedCodeableConcept" => {
                    raw_fixed.element("CodeableConcept", value, path)?;
                }
                "fixedCodeableReference" => {
                    raw_fixed.value("CodeableReference", value, path)?;
                }
                "_fixedCodeableReference" => {
                    raw_fixed.element("CodeableReference", value, path)?;
                }
                "fixedCoding" => {
                    raw_fixed.value("Coding", value, path)?;
                }
                "_fixedCoding" => {
                    raw_fixed.element("Coding", value, path)?;
                }
                "fixedContactPoint" => {
                    raw_fixed.value("ContactPoint", value, path)?;
                }
                "_fixedContactPoint" => {
                    raw_fixed.element("ContactPoint", value, path)?;
                }
                "fixedCount" => {
                    raw_fixed.value("Count", value, path)?;
                }
                "_fixedCount" => {
                    raw_fixed.element("Count", value, path)?;
                }
                "fixedDistance" => {
                    raw_fixed.value("Distance", value, path)?;
                }
                "_fixedDistance" => {
                    raw_fixed.element("Distance", value, path)?;
                }
                "fixedDuration" => {
                    raw_fixed.value("Duration", value, path)?;
                }
                "_fixedDuration" => {
                    raw_fixed.element("Duration", value, path)?;
                }
                "fixedHumanName" => {
                    raw_fixed.value("HumanName", value, path)?;
                }
                "_fixedHumanName" => {
                    raw_fixed.element("HumanName", value, path)?;
                }
                "fixedIdentifier" => {
                    raw_fixed.value("Identifier", value, path)?;
                }
                "_fixedIdentifier" => {
                    raw_fixed.element("Identifier", value, path)?;
                }
                "fixedMoney" => {
                    raw_fixed.value("Money", value, path)?;
                }
                "_fixedMoney" => {
                    raw_fixed.element("Money", value, path)?;
                }
                "fixedPeriod" => {
                    raw_fixed.value("Period", value, path)?;
                }
                "_fixedPeriod" => {
                    raw_fixed.element("Period", value, path)?;
                }
                "fixedQuantity" => {
                    raw_fixed.value("Quantity", value, path)?;
                }
                "_fixedQuantity" => {
                    raw_fixed.element("Quantity", value, path)?;
                }
                "fixedRange" => {
                    raw_fixed.value("Range", value, path)?;
                }
                "_fixedRange" => {
                    raw_fixed.element("Range", value, path)?;
                }
                "fixedRatio" => {
                    raw_fixed.value("Ratio", value, path)?;
                }
                "_fixedRatio" => {
                    raw_fixed.element("Ratio", value, path)?;
                }
                "fixedRatioRange" => {
                    raw_fixed.value("RatioRange", value, path)?;
                }
                "_fixedRatioRange" => {
                    raw_fixed.element("RatioRange", value, path)?;
                }
                "fixedReference" => {
                    raw_fixed.value("Reference", value, path)?;
                }
                "_fixedReference" => {
                    raw_fixed.element("Reference", value, path)?;
                }
                "fixedSampledData" => {
                    raw_fixed.value("SampledData", value, path)?;
                }
                "_fixedSampledData" => {
                    raw_fixed.element("SampledData", value, path)?;
                }
                "fixedSignature" => {
                    raw_fixed.value("Signature", value, path)?;
                }
                "_fixedSignature" => {
                    raw_fixed.element("Signature", value, path)?;
                }
                "fixedTiming" => {
                    raw_fixed.value("Timing", value, path)?;
                }
                "_fixedTiming" => {
                    raw_fixed.element("Timing", value, path)?;
                }
                "fixedContactDetail" => {
                    raw_fixed.value("ContactDetail", value, path)?;
                }
                "_fixedContactDetail" => {
                    raw_fixed.element("ContactDetail", value, path)?;
                }
                "fixedDataRequirement" => {
                    raw_fixed.value("DataRequirement", value, path)?;
                }
                "_fixedDataRequirement" => {
                    raw_fixed.element("DataRequirement", value, path)?;
                }
                "fixedExpression" => {
                    raw_fixed.value("Expression", value, path)?;
                }
                "_fixedExpression" => {
                    raw_fixed.element("Expression", value, path)?;
                }
                "fixedParameterDefinition" => {
                    raw_fixed.value("ParameterDefinition", value, path)?;
                }
                "_fixedParameterDefinition" => {
                    raw_fixed.element("ParameterDefinition", value, path)?;
                }
                "fixedRelatedArtifact" => {
                    raw_fixed.value("RelatedArtifact", value, path)?;
                }
                "_fixedRelatedArtifact" => {
                    raw_fixed.element("RelatedArtifact", value, path)?;
                }
                "fixedTriggerDefinition" => {
                    raw_fixed.value("TriggerDefinition", value, path)?;
                }
                "_fixedTriggerDefinition" => {
                    raw_fixed.element("TriggerDefinition", value, path)?;
                }
                "fixedUsageContext" => {
                    raw_fixed.value("UsageContext", value, path)?;
                }
                "_fixedUsageContext" => {
                    raw_fixed.element("UsageContext", value, path)?;
                }
                "fixedAvailability" => {
                    raw_fixed.value("Availability", value, path)?;
                }
                "_fixedAvailability" => {
                    raw_fixed.element("Availability", value, path)?;
                }
                "fixedExtendedContactDetail" => {
                    raw_fixed.value("ExtendedContactDetail", value, path)?;
                }
                "_fixedExtendedContactDetail" => {
                    raw_fixed.element("ExtendedContactDetail", value, path)?;
                }
                "fixedVirtualServiceDetail" => {
                    raw_fixed.value("VirtualServiceDetail", value, path)?;
                }
                "_fixedVirtualServiceDetail" => {
                    raw_fixed.element("VirtualServiceDetail", value, path)?;
                }
                "fixedDosage" => {
                    raw_fixed.value("Dosage", value, path)?;
                }
                "_fixedDosage" => {
                    raw_fixed.element("Dosage", value, path)?;
                }
                "fixedMeta" => {
                    raw_fixed.value("Meta", value, path)?;
                }
                "_fixedMeta" => {
                    raw_fixed.element("Meta", value, path)?;
                }
                "patternBase64Binary" => {
                    raw_pattern.value("Base64Binary", value, path)?;
                }
                "_patternBase64Binary" => {
                    raw_pattern.element("Base64Binary", value, path)?;
                }
                "patternBoolean" => {
                    raw_pattern.value("Boolean", value, path)?;
                }
                "_patternBoolean" => {
                    raw_pattern.element("Boolean", value, path)?;
                }
                "patternCanonical" => {
                    raw_pattern.value("Canonical", value, path)?;
                }
                "_patternCanonical" => {
                    raw_pattern.element("Canonical", value, path)?;
                }
                "patternCode" => {
                    raw_pattern.value("Code", value, path)?;
                }
                "_patternCode" => {
                    raw_pattern.element("Code", value, path)?;
                }
                "patternDate" => {
                    raw_pattern.value("Date", value, path)?;
                }
                "_patternDate" => {
                    raw_pattern.element("Date", value, path)?;
                }
                "patternDateTime" => {
                    raw_pattern.value("DateTime", value, path)?;
                }
                "_patternDateTime" => {
                    raw_pattern.element("DateTime", value, path)?;
                }
                "patternDecimal" => {
                    raw_pattern.value("Decimal", value, path)?;
                }
                "_patternDecimal" => {
                    raw_pattern.element("Decimal", value, path)?;
                }
                "patternId" => {
                    raw_pattern.value("Id", value, path)?;
                }
                "_patternId" => {
                    raw_pattern.element("Id", value, path)?;
                }
                "patternInstant" => {
                    raw_pattern.value("Instant", value, path)?;
                }
                "_patternInstant" => {
                    raw_pattern.element("Instant", value, path)?;
                }
                "patternInteger" => {
                    raw_pattern.value("Integer", value, path)?;
                }
                "_patternInteger" => {
                    raw_pattern.element("Integer", value, path)?;
                }
                "patternInteger64" => {
                    raw_pattern.value("Integer64", value, path)?;
                }
                "_patternInteger64" => {
                    raw_pattern.element("Integer64", value, path)?;
                }
                "patternMarkdown" => {
                    raw_pattern.value("Markdown", value, path)?;
                }
                "_patternMarkdown" => {
                    raw_pattern.element("Markdown", value, path)?;
                }
                "patternOid" => {
                    raw_pattern.value("Oid", value, path)?;
                }
                "_patternOid" => {
                    raw_pattern.element("Oid", value, path)?;
                }
                "patternPositiveInt" => {
                    raw_pattern.value("PositiveInt", value, path)?;
                }
                "_patternPositiveInt" => {
                    raw_pattern.element("PositiveInt", value, path)?;
                }
                "patternString" => {
                    raw_pattern.value("String", value, path)?;
                }
                "_patternString" => {
                    raw_pattern.element("String", value, path)?;
                }
                "patternTime" => {
                    raw_pattern.value("Time", value, path)?;
                }
                "_patternTime" => {
                    raw_pattern.element("Time", value, path)?;
                }
                "patternUnsignedInt" => {
                    raw_pattern.value("UnsignedInt", value, path)?;
                }
                "_patternUnsignedInt" => {
                    raw_pattern.element("UnsignedInt", value, path)?;
                }
                "patternUri" => {
                    raw_pattern.value("Uri", value, path)?;
                }
                "_patternUri" => {
                    raw_pattern.element("Uri", value, path)?;
                }
                "patternUrl" => {
                    raw_pattern.value("Url", value, path)?;
                }
                "_patternUrl" => {
                    raw_pattern.element("Url", value, path)?;
                }
                "patternUuid" => {
                    raw_pattern.value("Uuid", value, path)?;
                }
                "_patternUuid" => {
                    raw_pattern.element("Uuid", value, path)?;
                }
                "patternAddress" => {
                    raw_pattern.value("Address", value, path)?;
                }
                "_patternAddress" => {
                    raw_pattern.element("Address", value, path)?;
                }
                "patternAge" => {
                    raw_pattern.value("Age", value, path)?;
                }
                "_patternAge" => {
                    raw_pattern.element("Age", value, path)?;
                }
                "patternAnnotation" => {
                    raw_pattern.value("Annotation", value, path)?;
                }
                "_patternAnnotation" => {
                    raw_pattern.element("Annotation", value, path)?;
                }
                "patternAttachment" => {
                    raw_pattern.value("Attachment", value, path)?;
                }
                "_patternAttachment" => {
                    raw_pattern.element("Attachment", value, path)?;
                }
                "patternCodeableConcept" => {
                    raw_pattern.value("CodeableConcept", value, path)?;
                }
                "_patternCodeableConcept" => {
                    raw_pattern.element("CodeableConcept", value, path)?;
                }
                "patternCodeableReference" => {
                    raw_pattern.value("CodeableReference", value, path)?;
                }
                "_patternCodeableReference" => {
                    raw_pattern.element("CodeableReference", value, path)?;
                }
                "patternCoding" => {
                    raw_pattern.value("Coding", value, path)?;
                }
                "_patternCoding" => {
                    raw_pattern.element("Coding", value, path)?;
                }
                "patternContactPoint" => {
                    raw_pattern.value("ContactPoint", value, path)?;
                }
                "_patternContactPoint" => {
                    raw_pattern.element("ContactPoint", value, path)?;
                }
                "patternCount" => {
                    raw_pattern.value("Count", value, path)?;
                }
                "_patternCount" => {
                    raw_pattern.element("Count", value, path)?;
                }
                "patternDistance" => {
                    raw_pattern.value("Distance", value, path)?;
                }
                "_patternDistance" => {
                    raw_pattern.element("Distance", value, path)?;
                }
                "patternDuration" => {
                    raw_pattern.value("Duration", value, path)?;
                }
                "_patternDuration" => {
                    raw_pattern.element("Duration", value, path)?;
                }
                "patternHumanName" => {
                    raw_pattern.value("HumanName", value, path)?;
                }
                "_patternHumanName" => {
                    raw_pattern.element("HumanName", value, path)?;
                }
                "patternIdentifier" => {
                    raw_pattern.value("Identifier", value, path)?;
                }
                "_patternIdentifier" => {
                    raw_pattern.element("Identifier", value, path)?;
                }
                "patternMoney" => {
                    raw_pattern.value("Money", value, path)?;
                }
                "_patternMoney" => {
                    raw_pattern.element("Money", value, path)?;
                }
                "patternPeriod" => {
                    raw_pattern.value("Period", value, path)?;
                }
                "_patternPeriod" => {
                    raw_pattern.element("Period", value, path)?;
                }
                "patternQuantity" => {
                    raw_pattern.value("Quantity", value, path)?;
                }
                "_patternQuantity" => {
                    raw_pattern.element("Quantity", value, path)?;
                }
                "patternRange" => {
                    raw_pattern.value("Range", value, path)?;
                }
                "_patternRange" => {
                    raw_pattern.element("Range", value, path)?;
                }
                "patternRatio" => {
                    raw_pattern.value("Ratio", value, path)?;
                }
                "_patternRatio" => {
                    raw_pattern.element("Ratio", value, path)?;
                }
                "patternRatioRange" => {
                    raw_pattern.value("RatioRange", value, path)?;
                }
                "_patternRatioRange" => {
                    raw_pattern.element("RatioRange", value, path)?;
                }
                "patternReference" => {
                    raw_pattern.value("Reference", value, path)?;
                }
                "_patternReference" => {
                    raw_pattern.element("Reference", value, path)?;
                }
                "patternSampledData" => {
                    raw_pattern.value("SampledData", value, path)?;
                }
                "_patternSampledData" => {
                    raw_pattern.element("SampledData", value, path)?;
                }
                "patternSignature" => {
                    raw_pattern.value("Signature", value, path)?;
                }
                "_patternSignature" => {
                    raw_pattern.element("Signature", value, path)?;
                }
                "patternTiming" => {
                    raw_pattern.value("Timing", value, path)?;
                }
                "_patternTiming" => {
                    raw_pattern.element("Timing", value, path)?;
                }
                "patternContactDetail" => {
                    raw_pattern.value("ContactDetail", value, path)?;
                }
                "_patternContactDetail" => {
                    raw_pattern.element("ContactDetail", value, path)?;
                }
                "patternDataRequirement" => {
                    raw_pattern.value("DataRequirement", value, path)?;
                }
                "_patternDataRequirement" => {
                    raw_pattern.element("DataRequirement", value, path)?;
                }
                "patternExpression" => {
                    raw_pattern.value("Expression", value, path)?;
                }
                "_patternExpression" => {
                    raw_pattern.element("Expression", value, path)?;
                }
                "patternParameterDefinition" => {
                    raw_pattern.value("ParameterDefinition", value, path)?;
                }
                "_patternParameterDefinition" => {
                    raw_pattern.element("ParameterDefinition", value, path)?;
                }
                "patternRelatedArtifact" => {
                    raw_pattern.value("RelatedArtifact", value, path)?;
                }
                "_patternRelatedArtifact" => {
                    raw_pattern.element("RelatedArtifact", value, path)?;
                }
                "patternTriggerDefinition" => {
                    raw_pattern.value("TriggerDefinition", value, path)?;
                }
                "_patternTriggerDefinition" => {
                    raw_pattern.element("TriggerDefinition", value, path)?;
                }
                "patternUsageContext" => {
                    raw_pattern.value("UsageContext", value, path)?;
                }
                "_patternUsageContext" => {
                    raw_pattern.element("UsageContext", value, path)?;
                }
                "patternAvailability" => {
                    raw_pattern.value("Availability", value, path)?;
                }
                "_patternAvailability" => {
                    raw_pattern.element("Availability", value, path)?;
                }
                "patternExtendedContactDetail" => {
                    raw_pattern.value("ExtendedContactDetail", value, path)?;
                }
                "_patternExtendedContactDetail" => {
                    raw_pattern.element("ExtendedContactDetail", value, path)?;
                }
                "patternVirtualServiceDetail" => {
                    raw_pattern.value("VirtualServiceDetail", value, path)?;
                }
                "_patternVirtualServiceDetail" => {
                    raw_pattern.element("VirtualServiceDetail", value, path)?;
                }
                "patternDosage" => {
                    raw_pattern.value("Dosage", value, path)?;
                }
                "_patternDosage" => {
                    raw_pattern.element("Dosage", value, path)?;
                }
                "patternMeta" => {
                    raw_pattern.value("Meta", value, path)?;
                }
                "_patternMeta" => {
                    raw_pattern.element("Meta", value, path)?;
                }
                "example" => {
                    raw_example = Some(value);
                }
                "minValueDate" => {
                    raw_min_value.value("Date", value, path)?;
                }
                "_minValueDate" => {
                    raw_min_value.element("Date", value, path)?;
                }
                "minValueDateTime" => {
                    raw_min_value.value("DateTime", value, path)?;
                }
                "_minValueDateTime" => {
                    raw_min_value.element("DateTime", value, path)?;
                }
                "minValueInstant" => {
                    raw_min_value.value("Instant", value, path)?;
                }
                "_minValueInstant" => {
                    raw_min_value.element("Instant", value, path)?;
                }
                "minValueTime" => {
                    raw_min_value.value("Time", value, path)?;
                }
                "_minValueTime" => {
                    raw_min_value.element("Time", value, path)?;
                }
                "minValueDecimal" => {
                    raw_min_value.value("Decimal", value, path)?;
                }
                "_minValueDecimal" => {
                    raw_min_value.element("Decimal", value, path)?;
                }
                "minValueInteger" => {
                    raw_min_value.value("Integer", value, path)?;
                }
                "_minValueInteger" => {
                    raw_min_value.element("Integer", value, path)?;
                }
                "minValueInteger64" => {
                    raw_min_value.value("Integer64", value, path)?;
                }
                "_minValueInteger64" => {
                    raw_min_value.element("Integer64", value, path)?;
                }
                "minValuePositiveInt" => {
                    raw_min_value.value("PositiveInt", value, path)?;
                }
                "_minValuePositiveInt" => {
                    raw_min_value.element("PositiveInt", value, path)?;
                }
                "minValueUnsignedInt" => {
                    raw_min_value.value("UnsignedInt", value, path)?;
                }
                "_minValueUnsignedInt" => {
                    raw_min_value.element("UnsignedInt", value, path)?;
                }
                "minValueQuantity" => {
                    raw_min_value.value("Quantity", value, path)?;
                }
                "_minValueQuantity" => {
                    raw_min_value.element("Quantity", value, path)?;
                }
                "maxValueDate" => {
                    raw_max_value.value("Date", value, path)?;
                }
                "_maxValueDate" => {
                    raw_max_value.element("Date", value, path)?;
                }
                "maxValueDateTime" => {
                    raw_max_value.value("DateTime", value, path)?;
                }
                "_maxValueDateTime" => {
                    raw_max_value.element("DateTime", value, path)?;
                }
                "maxValueInstant" => {
                    raw_max_value.value("Instant", value, path)?;
                }
                "_maxValueInstant" => {
                    raw_max_value.element("Instant", value, path)?;
                }
                "maxValueTime" => {
                    raw_max_value.value("Time", value, path)?;
                }
                "_maxValueTime" => {
                    raw_max_value.element("Time", value, path)?;
                }
                "maxValueDecimal" => {
                    raw_max_value.value("Decimal", value, path)?;
                }
                "_maxValueDecimal" => {
                    raw_max_value.element("Decimal", value, path)?;
                }
                "maxValueInteger" => {
                    raw_max_value.value("Integer", value, path)?;
                }
                "_maxValueInteger" => {
                    raw_max_value.element("Integer", value, path)?;
                }
                "maxValueInteger64" => {
                    raw_max_value.value("Integer64", value, path)?;
                }
                "_maxValueInteger64" => {
                    raw_max_value.element("Integer64", value, path)?;
                }
                "maxValuePositiveInt" => {
                    raw_max_value.value("PositiveInt", value, path)?;
                }
                "_maxValuePositiveInt" => {
                    raw_max_value.element("PositiveInt", value, path)?;
                }
                "maxValueUnsignedInt" => {
                    raw_max_value.value("UnsignedInt", value, path)?;
                }
                "_maxValueUnsignedInt" => {
                    raw_max_value.element("UnsignedInt", value, path)?;
                }
                "maxValueQuantity" => {
                    raw_max_value.value("Quantity", value, path)?;
                }
                "_maxValueQuantity" => {
                    raw_max_value.element("Quantity", value, path)?;
                }
                "maxLength" => {
                    raw_max_length = Some(value);
                }
                "_maxLength" => {
                    raw_max_length_element = Some(value);
                }
                "condition" => {
                    raw_condition = Some(value);
                }
                "_condition" => {
                    raw_condition_element = Some(value);
                }
                "constraint" => {
                    raw_constraint = Some(value);
                }
                "mustHaveValue" => {
                    raw_must_have_value = Some(value);
                }
                "_mustHaveValue" => {
                    raw_must_have_value_element = Some(value);
                }
                "valueAlternatives" => {
                    raw_value_alternatives = Some(value);
                }
                "_valueAlternatives" => {
                    raw_value_alternatives_element = Some(value);
                }
                "mustSupport" => {
                    raw_must_support = Some(value);
                }
                "_mustSupport" => {
                    raw_must_support_element = Some(value);
                }
                "isModifier" => {
                    raw_is_modifier = Some(value);
                }
                "_isModifier" => {
                    raw_is_modifier_element = Some(value);
                }
                "isModifierReason" => {
                    raw_is_modifier_reason = Some(value);
                }
                "_isModifierReason" => {
                    raw_is_modifier_reason_element = Some(value);
                }
                "isSummary" => {
                    raw_is_summary = Some(value);
                }
                "_isSummary" => {
                    raw_is_summary_element = Some(value);
                }
                "binding" => {
                    raw_binding = Some(value);
                }
                "mapping" => {
                    raw_mapping = 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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        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_path = path.with("path", |path| {
            super::super::codec::Primitive::from_json_parts(raw_path, raw_path_element, path)
        })?;
        let mut field_representation = Vec::new();
        for (index, (value, element)) in
            super::super::codec::pair_arrays(raw_representation, raw_representation_element, path)?
                .into_iter()
                .enumerate()
        {
            field_representation.push(path.with_index("representation", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let field_slice_name = match (raw_slice_name, raw_slice_name_element) {
            (None, None) => None,
            (value, element) => Some(path.with("sliceName", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_slice_is_constraining =
            match (raw_slice_is_constraining, raw_slice_is_constraining_element) {
                (None, None) => None,
                (value, element) => Some(path.with("sliceIsConstraining", |path| {
                    super::super::codec::Primitive::from_json_parts(value, element, path)
                })?),
            };
        let field_label = match (raw_label, raw_label_element) {
            (None, None) => None,
            (value, element) => Some(path.with("label", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_code = Vec::new();
        if let Some(raw) = raw_code {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_code.push(path.with_index("code", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_slicing = raw_slicing
            .map(|value| {
                path.with("slicing", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_short = match (raw_short, raw_short_element) {
            (None, None) => None,
            (value, element) => Some(path.with("short", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_definition = match (raw_definition, raw_definition_element) {
            (None, None) => None,
            (value, element) => Some(path.with("definition", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_comment = match (raw_comment, raw_comment_element) {
            (None, None) => None,
            (value, element) => Some(path.with("comment", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_requirements = match (raw_requirements, raw_requirements_element) {
            (None, None) => None,
            (value, element) => Some(path.with("requirements", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_alias = Vec::new();
        for (index, (value, element)) in
            super::super::codec::pair_arrays(raw_alias, raw_alias_element, path)?
                .into_iter()
                .enumerate()
        {
            field_alias.push(path.with_index("alias", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, 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_base = raw_base
            .map(|value| {
                path.with("base", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_content_reference = match (raw_content_reference, raw_content_reference_element) {
            (None, None) => None,
            (value, element) => Some(path.with("contentReference", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_type = Vec::new();
        if let Some(raw) = raw_type {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_type.push(path.with_index("type", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_default_value = match raw_default_value.suffix {
            None => None,
            Some(suffix) => Some(path.with("defaultValue", |path| {
                ElementDefinitionDefaultValue::from_json_parts(
                    suffix,
                    raw_default_value.value,
                    raw_default_value.element,
                    path,
                )
            })?),
        };
        let field_meaning_when_missing =
            match (raw_meaning_when_missing, raw_meaning_when_missing_element) {
                (None, None) => None,
                (value, element) => Some(path.with("meaningWhenMissing", |path| {
                    super::super::codec::Primitive::from_json_parts(value, element, path)
                })?),
            };
        let field_order_meaning = match (raw_order_meaning, raw_order_meaning_element) {
            (None, None) => None,
            (value, element) => Some(path.with("orderMeaning", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_fixed = match raw_fixed.suffix {
            None => None,
            Some(suffix) => Some(path.with("fixed", |path| {
                ElementDefinitionFixed::from_json_parts(
                    suffix,
                    raw_fixed.value,
                    raw_fixed.element,
                    path,
                )
            })?),
        };
        let field_pattern = match raw_pattern.suffix {
            None => None,
            Some(suffix) => Some(path.with("pattern", |path| {
                ElementDefinitionPattern::from_json_parts(
                    suffix,
                    raw_pattern.value,
                    raw_pattern.element,
                    path,
                )
            })?),
        };
        let mut field_example = Vec::new();
        if let Some(raw) = raw_example {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_example.push(path.with_index("example", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_min_value = match raw_min_value.suffix {
            None => None,
            Some(suffix) => Some(path.with("minValue", |path| {
                ElementDefinitionMinValue::from_json_parts(
                    suffix,
                    raw_min_value.value,
                    raw_min_value.element,
                    path,
                )
            })?),
        };
        let field_max_value = match raw_max_value.suffix {
            None => None,
            Some(suffix) => Some(path.with("maxValue", |path| {
                ElementDefinitionMaxValue::from_json_parts(
                    suffix,
                    raw_max_value.value,
                    raw_max_value.element,
                    path,
                )
            })?),
        };
        let field_max_length = match (raw_max_length, raw_max_length_element) {
            (None, None) => None,
            (value, element) => Some(path.with("maxLength", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_condition = Vec::new();
        for (index, (value, element)) in
            super::super::codec::pair_arrays(raw_condition, raw_condition_element, path)?
                .into_iter()
                .enumerate()
        {
            field_condition.push(path.with_index("condition", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let mut field_constraint = Vec::new();
        if let Some(raw) = raw_constraint {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_constraint.push(path.with_index("constraint", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_must_have_value = match (raw_must_have_value, raw_must_have_value_element) {
            (None, None) => None,
            (value, element) => Some(path.with("mustHaveValue", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_value_alternatives = Vec::new();
        for (index, (value, element)) in super::super::codec::pair_arrays(
            raw_value_alternatives,
            raw_value_alternatives_element,
            path,
        )?
        .into_iter()
        .enumerate()
        {
            field_value_alternatives.push(path.with_index("valueAlternatives", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let field_must_support = match (raw_must_support, raw_must_support_element) {
            (None, None) => None,
            (value, element) => Some(path.with("mustSupport", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_is_modifier = match (raw_is_modifier, raw_is_modifier_element) {
            (None, None) => None,
            (value, element) => Some(path.with("isModifier", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_is_modifier_reason =
            match (raw_is_modifier_reason, raw_is_modifier_reason_element) {
                (None, None) => None,
                (value, element) => Some(path.with("isModifierReason", |path| {
                    super::super::codec::Primitive::from_json_parts(value, element, path)
                })?),
            };
        let field_is_summary = match (raw_is_summary, raw_is_summary_element) {
            (None, None) => None,
            (value, element) => Some(path.with("isSummary", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_binding = raw_binding
            .map(|value| {
                path.with("binding", |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_mapping = Vec::new();
        if let Some(raw) = raw_mapping {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_mapping.push(path.with_index("mapping", 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,
            path: field_path,
            representation: field_representation,
            slice_name: field_slice_name,
            slice_is_constraining: field_slice_is_constraining,
            label: field_label,
            code: field_code,
            slicing: field_slicing,
            short: field_short,
            definition: field_definition,
            comment: field_comment,
            requirements: field_requirements,
            alias: field_alias,
            min: field_min,
            max: field_max,
            base: field_base,
            content_reference: field_content_reference,
            r#type: field_type,
            default_value: field_default_value,
            meaning_when_missing: field_meaning_when_missing,
            order_meaning: field_order_meaning,
            fixed: field_fixed,
            pattern: field_pattern,
            example: field_example,
            min_value: field_min_value,
            max_value: field_max_value,
            max_length: field_max_length,
            condition: field_condition,
            constraint: field_constraint,
            must_have_value: field_must_have_value,
            value_alternatives: field_value_alternatives,
            must_support: field_must_support,
            is_modifier: field_is_modifier,
            is_modifier_reason: field_is_modifier_reason,
            is_summary: field_is_summary,
            binding: field_binding,
            mapping: field_mapping,
        })
    }
}

impl serde::Serialize for ElementDefinition {
    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_list_entry(&mut map, "_alias", &self.alias)?;
        if let Some(item) = &self.comment {
            super::super::codec::element_entry(&mut map, "_comment", item)?;
        }
        super::super::codec::element_list_entry(&mut map, "_condition", &self.condition)?;
        if let Some(item) = &self.content_reference {
            super::super::codec::element_entry(&mut map, "_contentReference", item)?;
        }
        match &self.default_value {
            Some(ElementDefinitionDefaultValue::Base64Binary(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueBase64Binary", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Boolean(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueBoolean", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Canonical(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueCanonical", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Code(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueCode", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Date(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueDate", inner)?;
            }
            Some(ElementDefinitionDefaultValue::DateTime(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueDateTime", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Decimal(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueDecimal", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Id(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueId", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Instant(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueInstant", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Integer(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueInteger", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Integer64(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueInteger64", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Markdown(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueMarkdown", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Oid(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueOid", inner)?;
            }
            Some(ElementDefinitionDefaultValue::PositiveInt(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValuePositiveInt", inner)?;
            }
            Some(ElementDefinitionDefaultValue::String(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueString", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Time(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueTime", inner)?;
            }
            Some(ElementDefinitionDefaultValue::UnsignedInt(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueUnsignedInt", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Uri(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueUri", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Url(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueUrl", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Uuid(inner)) => {
                super::super::codec::element_entry(&mut map, "_defaultValueUuid", inner)?;
            }
            _ => {}
        }
        if let Some(item) = &self.definition {
            super::super::codec::element_entry(&mut map, "_definition", item)?;
        }
        match &self.fixed {
            Some(ElementDefinitionFixed::Base64Binary(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedBase64Binary", inner)?;
            }
            Some(ElementDefinitionFixed::Boolean(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedBoolean", inner)?;
            }
            Some(ElementDefinitionFixed::Canonical(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedCanonical", inner)?;
            }
            Some(ElementDefinitionFixed::Code(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedCode", inner)?;
            }
            Some(ElementDefinitionFixed::Date(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedDate", inner)?;
            }
            Some(ElementDefinitionFixed::DateTime(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedDateTime", inner)?;
            }
            Some(ElementDefinitionFixed::Decimal(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedDecimal", inner)?;
            }
            Some(ElementDefinitionFixed::Id(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedId", inner)?;
            }
            Some(ElementDefinitionFixed::Instant(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedInstant", inner)?;
            }
            Some(ElementDefinitionFixed::Integer(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedInteger", inner)?;
            }
            Some(ElementDefinitionFixed::Integer64(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedInteger64", inner)?;
            }
            Some(ElementDefinitionFixed::Markdown(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedMarkdown", inner)?;
            }
            Some(ElementDefinitionFixed::Oid(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedOid", inner)?;
            }
            Some(ElementDefinitionFixed::PositiveInt(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedPositiveInt", inner)?;
            }
            Some(ElementDefinitionFixed::String(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedString", inner)?;
            }
            Some(ElementDefinitionFixed::Time(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedTime", inner)?;
            }
            Some(ElementDefinitionFixed::UnsignedInt(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedUnsignedInt", inner)?;
            }
            Some(ElementDefinitionFixed::Uri(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedUri", inner)?;
            }
            Some(ElementDefinitionFixed::Url(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedUrl", inner)?;
            }
            Some(ElementDefinitionFixed::Uuid(inner)) => {
                super::super::codec::element_entry(&mut map, "_fixedUuid", inner)?;
            }
            _ => {}
        }
        if let Some(item) = &self.is_modifier {
            super::super::codec::element_entry(&mut map, "_isModifier", item)?;
        }
        if let Some(item) = &self.is_modifier_reason {
            super::super::codec::element_entry(&mut map, "_isModifierReason", item)?;
        }
        if let Some(item) = &self.is_summary {
            super::super::codec::element_entry(&mut map, "_isSummary", item)?;
        }
        if let Some(item) = &self.label {
            super::super::codec::element_entry(&mut map, "_label", item)?;
        }
        if let Some(item) = &self.max {
            super::super::codec::element_entry(&mut map, "_max", item)?;
        }
        if let Some(item) = &self.max_length {
            super::super::codec::element_entry(&mut map, "_maxLength", item)?;
        }
        match &self.max_value {
            Some(ElementDefinitionMaxValue::Date(inner)) => {
                super::super::codec::element_entry(&mut map, "_maxValueDate", inner)?;
            }
            Some(ElementDefinitionMaxValue::DateTime(inner)) => {
                super::super::codec::element_entry(&mut map, "_maxValueDateTime", inner)?;
            }
            Some(ElementDefinitionMaxValue::Decimal(inner)) => {
                super::super::codec::element_entry(&mut map, "_maxValueDecimal", inner)?;
            }
            Some(ElementDefinitionMaxValue::Instant(inner)) => {
                super::super::codec::element_entry(&mut map, "_maxValueInstant", inner)?;
            }
            Some(ElementDefinitionMaxValue::Integer(inner)) => {
                super::super::codec::element_entry(&mut map, "_maxValueInteger", inner)?;
            }
            Some(ElementDefinitionMaxValue::Integer64(inner)) => {
                super::super::codec::element_entry(&mut map, "_maxValueInteger64", inner)?;
            }
            Some(ElementDefinitionMaxValue::PositiveInt(inner)) => {
                super::super::codec::element_entry(&mut map, "_maxValuePositiveInt", inner)?;
            }
            Some(ElementDefinitionMaxValue::Time(inner)) => {
                super::super::codec::element_entry(&mut map, "_maxValueTime", inner)?;
            }
            Some(ElementDefinitionMaxValue::UnsignedInt(inner)) => {
                super::super::codec::element_entry(&mut map, "_maxValueUnsignedInt", inner)?;
            }
            _ => {}
        }
        if let Some(item) = &self.meaning_when_missing {
            super::super::codec::element_entry(&mut map, "_meaningWhenMissing", item)?;
        }
        if let Some(item) = &self.min {
            super::super::codec::element_entry(&mut map, "_min", item)?;
        }
        match &self.min_value {
            Some(ElementDefinitionMinValue::Date(inner)) => {
                super::super::codec::element_entry(&mut map, "_minValueDate", inner)?;
            }
            Some(ElementDefinitionMinValue::DateTime(inner)) => {
                super::super::codec::element_entry(&mut map, "_minValueDateTime", inner)?;
            }
            Some(ElementDefinitionMinValue::Decimal(inner)) => {
                super::super::codec::element_entry(&mut map, "_minValueDecimal", inner)?;
            }
            Some(ElementDefinitionMinValue::Instant(inner)) => {
                super::super::codec::element_entry(&mut map, "_minValueInstant", inner)?;
            }
            Some(ElementDefinitionMinValue::Integer(inner)) => {
                super::super::codec::element_entry(&mut map, "_minValueInteger", inner)?;
            }
            Some(ElementDefinitionMinValue::Integer64(inner)) => {
                super::super::codec::element_entry(&mut map, "_minValueInteger64", inner)?;
            }
            Some(ElementDefinitionMinValue::PositiveInt(inner)) => {
                super::super::codec::element_entry(&mut map, "_minValuePositiveInt", inner)?;
            }
            Some(ElementDefinitionMinValue::Time(inner)) => {
                super::super::codec::element_entry(&mut map, "_minValueTime", inner)?;
            }
            Some(ElementDefinitionMinValue::UnsignedInt(inner)) => {
                super::super::codec::element_entry(&mut map, "_minValueUnsignedInt", inner)?;
            }
            _ => {}
        }
        if let Some(item) = &self.must_have_value {
            super::super::codec::element_entry(&mut map, "_mustHaveValue", item)?;
        }
        if let Some(item) = &self.must_support {
            super::super::codec::element_entry(&mut map, "_mustSupport", item)?;
        }
        if let Some(item) = &self.order_meaning {
            super::super::codec::element_entry(&mut map, "_orderMeaning", item)?;
        }
        super::super::codec::element_entry(&mut map, "_path", &self.path)?;
        match &self.pattern {
            Some(ElementDefinitionPattern::Base64Binary(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternBase64Binary", inner)?;
            }
            Some(ElementDefinitionPattern::Boolean(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternBoolean", inner)?;
            }
            Some(ElementDefinitionPattern::Canonical(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternCanonical", inner)?;
            }
            Some(ElementDefinitionPattern::Code(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternCode", inner)?;
            }
            Some(ElementDefinitionPattern::Date(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternDate", inner)?;
            }
            Some(ElementDefinitionPattern::DateTime(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternDateTime", inner)?;
            }
            Some(ElementDefinitionPattern::Decimal(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternDecimal", inner)?;
            }
            Some(ElementDefinitionPattern::Id(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternId", inner)?;
            }
            Some(ElementDefinitionPattern::Instant(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternInstant", inner)?;
            }
            Some(ElementDefinitionPattern::Integer(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternInteger", inner)?;
            }
            Some(ElementDefinitionPattern::Integer64(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternInteger64", inner)?;
            }
            Some(ElementDefinitionPattern::Markdown(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternMarkdown", inner)?;
            }
            Some(ElementDefinitionPattern::Oid(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternOid", inner)?;
            }
            Some(ElementDefinitionPattern::PositiveInt(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternPositiveInt", inner)?;
            }
            Some(ElementDefinitionPattern::String(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternString", inner)?;
            }
            Some(ElementDefinitionPattern::Time(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternTime", inner)?;
            }
            Some(ElementDefinitionPattern::UnsignedInt(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternUnsignedInt", inner)?;
            }
            Some(ElementDefinitionPattern::Uri(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternUri", inner)?;
            }
            Some(ElementDefinitionPattern::Url(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternUrl", inner)?;
            }
            Some(ElementDefinitionPattern::Uuid(inner)) => {
                super::super::codec::element_entry(&mut map, "_patternUuid", inner)?;
            }
            _ => {}
        }
        super::super::codec::element_list_entry(&mut map, "_representation", &self.representation)?;
        if let Some(item) = &self.requirements {
            super::super::codec::element_entry(&mut map, "_requirements", item)?;
        }
        if let Some(item) = &self.short {
            super::super::codec::element_entry(&mut map, "_short", item)?;
        }
        if let Some(item) = &self.slice_is_constraining {
            super::super::codec::element_entry(&mut map, "_sliceIsConstraining", item)?;
        }
        if let Some(item) = &self.slice_name {
            super::super::codec::element_entry(&mut map, "_sliceName", item)?;
        }
        super::super::codec::element_list_entry(
            &mut map,
            "_valueAlternatives",
            &self.value_alternatives,
        )?;
        super::super::codec::value_list_entry(&mut map, "alias", &self.alias)?;
        if let Some(item) = &self.base {
            serde::ser::SerializeMap::serialize_entry(&mut map, "base", item)?;
        }
        if let Some(item) = &self.binding {
            serde::ser::SerializeMap::serialize_entry(&mut map, "binding", item)?;
        }
        if !self.code.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "code", &self.code)?;
        }
        if let Some(item) = &self.comment {
            super::super::codec::value_entry(&mut map, "comment", item)?;
        }
        super::super::codec::value_list_entry(&mut map, "condition", &self.condition)?;
        if !self.constraint.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "constraint", &self.constraint)?;
        }
        if let Some(item) = &self.content_reference {
            super::super::codec::value_entry(&mut map, "contentReference", item)?;
        }
        match &self.default_value {
            Some(ElementDefinitionDefaultValue::Address(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueAddress",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Age(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueAge",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Annotation(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueAnnotation",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Attachment(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueAttachment",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Availability(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueAvailability",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Base64Binary(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueBase64Binary", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Boolean(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueBoolean", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Canonical(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueCanonical", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Code(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueCode", inner)?;
            }
            Some(ElementDefinitionDefaultValue::CodeableConcept(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueCodeableConcept",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::CodeableReference(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueCodeableReference",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Coding(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueCoding",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::ContactDetail(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueContactDetail",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::ContactPoint(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueContactPoint",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Count(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueCount",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::DataRequirement(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueDataRequirement",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Date(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueDate", inner)?;
            }
            Some(ElementDefinitionDefaultValue::DateTime(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueDateTime", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Decimal(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueDecimal", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Distance(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueDistance",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Dosage(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueDosage",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Duration(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueDuration",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Expression(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueExpression",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::ExtendedContactDetail(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueExtendedContactDetail",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::HumanName(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueHumanName",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Id(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueId", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Identifier(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueIdentifier",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Instant(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueInstant", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Integer(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueInteger", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Integer64(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueInteger64", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Markdown(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueMarkdown", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Meta(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueMeta",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Money(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueMoney",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Oid(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueOid", inner)?;
            }
            Some(ElementDefinitionDefaultValue::ParameterDefinition(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueParameterDefinition",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Period(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValuePeriod",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::PositiveInt(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValuePositiveInt", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Quantity(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueQuantity",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Range(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueRange",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Ratio(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueRatio",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::RatioRange(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueRatioRange",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Reference(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueReference",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::RelatedArtifact(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueRelatedArtifact",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::SampledData(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueSampledData",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Signature(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueSignature",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::String(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueString", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Time(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueTime", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Timing(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueTiming",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::TriggerDefinition(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueTriggerDefinition",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::UnsignedInt(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueUnsignedInt", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Uri(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueUri", inner)?;
            }
            Some(ElementDefinitionDefaultValue::Url(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueUrl", inner)?;
            }
            Some(ElementDefinitionDefaultValue::UsageContext(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueUsageContext",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionDefaultValue::Uuid(inner)) => {
                super::super::codec::value_entry(&mut map, "defaultValueUuid", inner)?;
            }
            Some(ElementDefinitionDefaultValue::VirtualServiceDetail(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "defaultValueVirtualServiceDetail",
                    inner.as_ref(),
                )?;
            }
            None => {}
        }
        if let Some(item) = &self.definition {
            super::super::codec::value_entry(&mut map, "definition", item)?;
        }
        if !self.example.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "example", &self.example)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        match &self.fixed {
            Some(ElementDefinitionFixed::Address(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedAddress",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::Age(inner)) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "fixedAge", inner.as_ref())?;
            }
            Some(ElementDefinitionFixed::Annotation(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedAnnotation",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::Attachment(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedAttachment",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::Availability(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedAvailability",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::Base64Binary(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedBase64Binary", inner)?;
            }
            Some(ElementDefinitionFixed::Boolean(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedBoolean", inner)?;
            }
            Some(ElementDefinitionFixed::Canonical(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedCanonical", inner)?;
            }
            Some(ElementDefinitionFixed::Code(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedCode", inner)?;
            }
            Some(ElementDefinitionFixed::CodeableConcept(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedCodeableConcept",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::CodeableReference(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedCodeableReference",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::Coding(inner)) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "fixedCoding", inner.as_ref())?;
            }
            Some(ElementDefinitionFixed::ContactDetail(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedContactDetail",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::ContactPoint(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedContactPoint",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::Count(inner)) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "fixedCount", inner.as_ref())?;
            }
            Some(ElementDefinitionFixed::DataRequirement(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedDataRequirement",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::Date(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedDate", inner)?;
            }
            Some(ElementDefinitionFixed::DateTime(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedDateTime", inner)?;
            }
            Some(ElementDefinitionFixed::Decimal(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedDecimal", inner)?;
            }
            Some(ElementDefinitionFixed::Distance(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedDistance",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::Dosage(inner)) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "fixedDosage", inner.as_ref())?;
            }
            Some(ElementDefinitionFixed::Duration(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedDuration",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::Expression(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedExpression",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::ExtendedContactDetail(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedExtendedContactDetail",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::HumanName(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedHumanName",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::Id(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedId", inner)?;
            }
            Some(ElementDefinitionFixed::Identifier(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedIdentifier",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::Instant(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedInstant", inner)?;
            }
            Some(ElementDefinitionFixed::Integer(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedInteger", inner)?;
            }
            Some(ElementDefinitionFixed::Integer64(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedInteger64", inner)?;
            }
            Some(ElementDefinitionFixed::Markdown(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedMarkdown", inner)?;
            }
            Some(ElementDefinitionFixed::Meta(inner)) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "fixedMeta", inner.as_ref())?;
            }
            Some(ElementDefinitionFixed::Money(inner)) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "fixedMoney", inner.as_ref())?;
            }
            Some(ElementDefinitionFixed::Oid(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedOid", inner)?;
            }
            Some(ElementDefinitionFixed::ParameterDefinition(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedParameterDefinition",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::Period(inner)) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "fixedPeriod", inner.as_ref())?;
            }
            Some(ElementDefinitionFixed::PositiveInt(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedPositiveInt", inner)?;
            }
            Some(ElementDefinitionFixed::Quantity(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedQuantity",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::Range(inner)) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "fixedRange", inner.as_ref())?;
            }
            Some(ElementDefinitionFixed::Ratio(inner)) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "fixedRatio", inner.as_ref())?;
            }
            Some(ElementDefinitionFixed::RatioRange(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedRatioRange",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::Reference(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedReference",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::RelatedArtifact(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedRelatedArtifact",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::SampledData(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedSampledData",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::Signature(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedSignature",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::String(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedString", inner)?;
            }
            Some(ElementDefinitionFixed::Time(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedTime", inner)?;
            }
            Some(ElementDefinitionFixed::Timing(inner)) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "fixedTiming", inner.as_ref())?;
            }
            Some(ElementDefinitionFixed::TriggerDefinition(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedTriggerDefinition",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::UnsignedInt(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedUnsignedInt", inner)?;
            }
            Some(ElementDefinitionFixed::Uri(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedUri", inner)?;
            }
            Some(ElementDefinitionFixed::Url(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedUrl", inner)?;
            }
            Some(ElementDefinitionFixed::UsageContext(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedUsageContext",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionFixed::Uuid(inner)) => {
                super::super::codec::value_entry(&mut map, "fixedUuid", inner)?;
            }
            Some(ElementDefinitionFixed::VirtualServiceDetail(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "fixedVirtualServiceDetail",
                    inner.as_ref(),
                )?;
            }
            None => {}
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if let Some(item) = &self.is_modifier {
            super::super::codec::value_entry(&mut map, "isModifier", item)?;
        }
        if let Some(item) = &self.is_modifier_reason {
            super::super::codec::value_entry(&mut map, "isModifierReason", item)?;
        }
        if let Some(item) = &self.is_summary {
            super::super::codec::value_entry(&mut map, "isSummary", item)?;
        }
        if let Some(item) = &self.label {
            super::super::codec::value_entry(&mut map, "label", item)?;
        }
        if !self.mapping.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "mapping", &self.mapping)?;
        }
        if let Some(item) = &self.max {
            super::super::codec::value_entry(&mut map, "max", item)?;
        }
        if let Some(item) = &self.max_length {
            super::super::codec::value_entry(&mut map, "maxLength", item)?;
        }
        match &self.max_value {
            Some(ElementDefinitionMaxValue::Date(inner)) => {
                super::super::codec::value_entry(&mut map, "maxValueDate", inner)?;
            }
            Some(ElementDefinitionMaxValue::DateTime(inner)) => {
                super::super::codec::value_entry(&mut map, "maxValueDateTime", inner)?;
            }
            Some(ElementDefinitionMaxValue::Decimal(inner)) => {
                super::super::codec::value_entry(&mut map, "maxValueDecimal", inner)?;
            }
            Some(ElementDefinitionMaxValue::Instant(inner)) => {
                super::super::codec::value_entry(&mut map, "maxValueInstant", inner)?;
            }
            Some(ElementDefinitionMaxValue::Integer(inner)) => {
                super::super::codec::value_entry(&mut map, "maxValueInteger", inner)?;
            }
            Some(ElementDefinitionMaxValue::Integer64(inner)) => {
                super::super::codec::value_entry(&mut map, "maxValueInteger64", inner)?;
            }
            Some(ElementDefinitionMaxValue::PositiveInt(inner)) => {
                super::super::codec::value_entry(&mut map, "maxValuePositiveInt", inner)?;
            }
            Some(ElementDefinitionMaxValue::Quantity(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "maxValueQuantity",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionMaxValue::Time(inner)) => {
                super::super::codec::value_entry(&mut map, "maxValueTime", inner)?;
            }
            Some(ElementDefinitionMaxValue::UnsignedInt(inner)) => {
                super::super::codec::value_entry(&mut map, "maxValueUnsignedInt", inner)?;
            }
            None => {}
        }
        if let Some(item) = &self.meaning_when_missing {
            super::super::codec::value_entry(&mut map, "meaningWhenMissing", item)?;
        }
        if let Some(item) = &self.min {
            super::super::codec::value_entry(&mut map, "min", item)?;
        }
        match &self.min_value {
            Some(ElementDefinitionMinValue::Date(inner)) => {
                super::super::codec::value_entry(&mut map, "minValueDate", inner)?;
            }
            Some(ElementDefinitionMinValue::DateTime(inner)) => {
                super::super::codec::value_entry(&mut map, "minValueDateTime", inner)?;
            }
            Some(ElementDefinitionMinValue::Decimal(inner)) => {
                super::super::codec::value_entry(&mut map, "minValueDecimal", inner)?;
            }
            Some(ElementDefinitionMinValue::Instant(inner)) => {
                super::super::codec::value_entry(&mut map, "minValueInstant", inner)?;
            }
            Some(ElementDefinitionMinValue::Integer(inner)) => {
                super::super::codec::value_entry(&mut map, "minValueInteger", inner)?;
            }
            Some(ElementDefinitionMinValue::Integer64(inner)) => {
                super::super::codec::value_entry(&mut map, "minValueInteger64", inner)?;
            }
            Some(ElementDefinitionMinValue::PositiveInt(inner)) => {
                super::super::codec::value_entry(&mut map, "minValuePositiveInt", inner)?;
            }
            Some(ElementDefinitionMinValue::Quantity(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "minValueQuantity",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionMinValue::Time(inner)) => {
                super::super::codec::value_entry(&mut map, "minValueTime", inner)?;
            }
            Some(ElementDefinitionMinValue::UnsignedInt(inner)) => {
                super::super::codec::value_entry(&mut map, "minValueUnsignedInt", inner)?;
            }
            None => {}
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if let Some(item) = &self.must_have_value {
            super::super::codec::value_entry(&mut map, "mustHaveValue", item)?;
        }
        if let Some(item) = &self.must_support {
            super::super::codec::value_entry(&mut map, "mustSupport", item)?;
        }
        if let Some(item) = &self.order_meaning {
            super::super::codec::value_entry(&mut map, "orderMeaning", item)?;
        }
        super::super::codec::value_entry(&mut map, "path", &self.path)?;
        match &self.pattern {
            Some(ElementDefinitionPattern::Address(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternAddress",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Age(inner)) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "patternAge", inner.as_ref())?;
            }
            Some(ElementDefinitionPattern::Annotation(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternAnnotation",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Attachment(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternAttachment",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Availability(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternAvailability",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Base64Binary(inner)) => {
                super::super::codec::value_entry(&mut map, "patternBase64Binary", inner)?;
            }
            Some(ElementDefinitionPattern::Boolean(inner)) => {
                super::super::codec::value_entry(&mut map, "patternBoolean", inner)?;
            }
            Some(ElementDefinitionPattern::Canonical(inner)) => {
                super::super::codec::value_entry(&mut map, "patternCanonical", inner)?;
            }
            Some(ElementDefinitionPattern::Code(inner)) => {
                super::super::codec::value_entry(&mut map, "patternCode", inner)?;
            }
            Some(ElementDefinitionPattern::CodeableConcept(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternCodeableConcept",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::CodeableReference(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternCodeableReference",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Coding(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternCoding",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::ContactDetail(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternContactDetail",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::ContactPoint(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternContactPoint",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Count(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternCount",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::DataRequirement(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternDataRequirement",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Date(inner)) => {
                super::super::codec::value_entry(&mut map, "patternDate", inner)?;
            }
            Some(ElementDefinitionPattern::DateTime(inner)) => {
                super::super::codec::value_entry(&mut map, "patternDateTime", inner)?;
            }
            Some(ElementDefinitionPattern::Decimal(inner)) => {
                super::super::codec::value_entry(&mut map, "patternDecimal", inner)?;
            }
            Some(ElementDefinitionPattern::Distance(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternDistance",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Dosage(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternDosage",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Duration(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternDuration",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Expression(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternExpression",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::ExtendedContactDetail(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternExtendedContactDetail",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::HumanName(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternHumanName",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Id(inner)) => {
                super::super::codec::value_entry(&mut map, "patternId", inner)?;
            }
            Some(ElementDefinitionPattern::Identifier(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternIdentifier",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Instant(inner)) => {
                super::super::codec::value_entry(&mut map, "patternInstant", inner)?;
            }
            Some(ElementDefinitionPattern::Integer(inner)) => {
                super::super::codec::value_entry(&mut map, "patternInteger", inner)?;
            }
            Some(ElementDefinitionPattern::Integer64(inner)) => {
                super::super::codec::value_entry(&mut map, "patternInteger64", inner)?;
            }
            Some(ElementDefinitionPattern::Markdown(inner)) => {
                super::super::codec::value_entry(&mut map, "patternMarkdown", inner)?;
            }
            Some(ElementDefinitionPattern::Meta(inner)) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "patternMeta", inner.as_ref())?;
            }
            Some(ElementDefinitionPattern::Money(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternMoney",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Oid(inner)) => {
                super::super::codec::value_entry(&mut map, "patternOid", inner)?;
            }
            Some(ElementDefinitionPattern::ParameterDefinition(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternParameterDefinition",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Period(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternPeriod",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::PositiveInt(inner)) => {
                super::super::codec::value_entry(&mut map, "patternPositiveInt", inner)?;
            }
            Some(ElementDefinitionPattern::Quantity(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternQuantity",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Range(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternRange",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Ratio(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternRatio",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::RatioRange(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternRatioRange",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Reference(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternReference",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::RelatedArtifact(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternRelatedArtifact",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::SampledData(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternSampledData",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Signature(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternSignature",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::String(inner)) => {
                super::super::codec::value_entry(&mut map, "patternString", inner)?;
            }
            Some(ElementDefinitionPattern::Time(inner)) => {
                super::super::codec::value_entry(&mut map, "patternTime", inner)?;
            }
            Some(ElementDefinitionPattern::Timing(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternTiming",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::TriggerDefinition(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternTriggerDefinition",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::UnsignedInt(inner)) => {
                super::super::codec::value_entry(&mut map, "patternUnsignedInt", inner)?;
            }
            Some(ElementDefinitionPattern::Uri(inner)) => {
                super::super::codec::value_entry(&mut map, "patternUri", inner)?;
            }
            Some(ElementDefinitionPattern::Url(inner)) => {
                super::super::codec::value_entry(&mut map, "patternUrl", inner)?;
            }
            Some(ElementDefinitionPattern::UsageContext(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternUsageContext",
                    inner.as_ref(),
                )?;
            }
            Some(ElementDefinitionPattern::Uuid(inner)) => {
                super::super::codec::value_entry(&mut map, "patternUuid", inner)?;
            }
            Some(ElementDefinitionPattern::VirtualServiceDetail(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "patternVirtualServiceDetail",
                    inner.as_ref(),
                )?;
            }
            None => {}
        }
        super::super::codec::value_list_entry(&mut map, "representation", &self.representation)?;
        if let Some(item) = &self.requirements {
            super::super::codec::value_entry(&mut map, "requirements", item)?;
        }
        if let Some(item) = &self.short {
            super::super::codec::value_entry(&mut map, "short", item)?;
        }
        if let Some(item) = &self.slice_is_constraining {
            super::super::codec::value_entry(&mut map, "sliceIsConstraining", item)?;
        }
        if let Some(item) = &self.slice_name {
            super::super::codec::value_entry(&mut map, "sliceName", item)?;
        }
        if let Some(item) = &self.slicing {
            serde::ser::SerializeMap::serialize_entry(&mut map, "slicing", item)?;
        }
        if !self.r#type.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "type", &self.r#type)?;
        }
        super::super::codec::value_list_entry(
            &mut map,
            "valueAlternatives",
            &self.value_alternatives,
        )?;
        serde::ser::SerializeMap::end(map)
    }
}

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

/// Base definition information for tools
///
/// Information about the base definition of the element, provided to make it
/// unnecessary for tools to trace the deviation of the element through the
/// derived and related profiles. When the element definition is not the
/// original definition of an element - e.g. either in a constraint on another
/// type, or for elements from a super type in a snap shot - then the
/// information in provided in the element definition may be different to the
/// base definition. On the original definition of the element, it will be same.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct ElementDefinitionBase {
    /// Unique id for inter-element referencing
    ///
    /// 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. To make the use of extensions safe and
    /// managable, there is a strict set of governance applied to the definition and
    /// use of extensions. Though any implementer can 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>,
    /// Path that identifies the base element
    ///
    /// The Path that identifies the base element - this matches the
    /// ElementDefinition.path for that element. Across FHIR, there is only one base
    /// definition of any element - that is, an element definition on a
    /// \[StructureDefinition\](structuredefinition.html\#) without a
    /// StructureDefinition.base.
    pub path: super::primitives::String,
    /// Min cardinality of the base element
    ///
    /// Minimum cardinality of the base element identified by the path.
    pub min: super::primitives::UnsignedInt,
    /// Max cardinality of the base element
    ///
    /// Maximum cardinality of the base element identified by the path.
    pub max: super::primitives::String,
}

impl super::super::codec::Json for ElementDefinitionBase {
    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 let Some(v) = super::super::codec::Primitive::value_json(&self.path)? {
            object.insert(std::string::String::from("path"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.path)? {
            object.insert(std::string::String::from("_path"), e);
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.min)? {
            object.insert(std::string::String::from("min"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.min)? {
            object.insert(std::string::String::from("_min"), e);
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.max)? {
            object.insert(std::string::String::from("max"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.max)? {
            object.insert(std::string::String::from("_max"), 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_path: Option<&super::super::codec::Value> = None;
        let mut raw_path_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;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "path" => {
                    raw_path = Some(value);
                }
                "_path" => {
                    raw_path_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);
                }
                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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        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 field_path = path.with("path", |path| {
            super::super::codec::Primitive::from_json_parts(raw_path, raw_path_element, path)
        })?;
        let field_min = path.with("min", |path| {
            super::super::codec::Primitive::from_json_parts(raw_min, raw_min_element, path)
        })?;
        let field_max = path.with("max", |path| {
            super::super::codec::Primitive::from_json_parts(raw_max, raw_max_element, path)
        })?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            path: field_path,
            min: field_min,
            max: field_max,
        })
    }
}

impl serde::Serialize for ElementDefinitionBase {
    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, "_max", &self.max)?;
        super::super::codec::element_entry(&mut map, "_min", &self.min)?;
        super::super::codec::element_entry(&mut map, "_path", &self.path)?;
        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, "max", &self.max)?;
        super::super::codec::value_entry(&mut map, "min", &self.min)?;
        super::super::codec::value_entry(&mut map, "path", &self.path)?;
        serde::ser::SerializeMap::end(map)
    }
}

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

/// ValueSet details if this is coded
///
/// Binds to a value set if this element is coded (code, Coding,
/// CodeableConcept, Quantity), or the data types (string, uri).
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct ElementDefinitionBinding {
    /// Unique id for inter-element referencing
    ///
    /// 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. To make the use of extensions safe and
    /// managable, there is a strict set of governance applied to the definition and
    /// use of extensions. Though any implementer can 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>,
    /// required | extensible | preferred | example | descriptive
    ///
    /// Indicates the degree of conformance expectations associated with this
    /// binding - that is, the degree to which the provided value set must be
    /// adhered to in the instances.
    pub strength: super::primitives::Code,
    /// Guidance on the codes to be used
    ///
    /// Free-text guidance on the codes that are appropriate for this element.
    pub description: Option<super::primitives::Markdown>,
    /// Source of value set
    ///
    /// Refers to the value set that identifies the set of codes the binding refers
    /// to.
    pub value_set: Option<super::primitives::Canonical>,
    /// Additional Bindings - more rules about the binding
    ///
    /// Additional bindings that help applications implementing this element.
    /// Additional bindings do not replace the main binding but provide more
    /// information and/or context.
    pub additional: Vec<ElementDefinitionBindingAdditional>,
}

impl super::super::codec::Json for ElementDefinitionBinding {
    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 let Some(v) = super::super::codec::Primitive::value_json(&self.strength)? {
            object.insert(std::string::String::from("strength"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.strength)? {
            object.insert(std::string::String::from("_strength"), e);
        }
        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 let Some(item) = &self.value_set {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("valueSet"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_valueSet"), e);
            }
        }
        if !self.additional.is_empty() {
            let mut items = Vec::with_capacity(self.additional.len());
            for item in &self.additional {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("additional"),
                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_strength: Option<&super::super::codec::Value> = None;
        let mut raw_strength_element: 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_value_set: Option<&super::super::codec::Value> = None;
        let mut raw_value_set_element: Option<&super::super::codec::Value> = None;
        let mut raw_additional: 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);
                }
                "strength" => {
                    raw_strength = Some(value);
                }
                "_strength" => {
                    raw_strength_element = Some(value);
                }
                "description" => {
                    raw_description = Some(value);
                }
                "_description" => {
                    raw_description_element = Some(value);
                }
                "valueSet" => {
                    raw_value_set = Some(value);
                }
                "_valueSet" => {
                    raw_value_set_element = Some(value);
                }
                "additional" => {
                    raw_additional = 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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        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 field_strength = path.with("strength", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_strength,
                raw_strength_element,
                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 field_value_set = match (raw_value_set, raw_value_set_element) {
            (None, None) => None,
            (value, element) => Some(path.with("valueSet", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_additional = Vec::new();
        if let Some(raw) = raw_additional {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_additional.push(path.with_index("additional", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        Ok(Self {
            id: field_id,
            extension: field_extension,
            strength: field_strength,
            description: field_description,
            value_set: field_value_set,
            additional: field_additional,
        })
    }
}

impl serde::Serialize for ElementDefinitionBinding {
    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.description {
            super::super::codec::element_entry(&mut map, "_description", item)?;
        }
        super::super::codec::element_entry(&mut map, "_strength", &self.strength)?;
        if let Some(item) = &self.value_set {
            super::super::codec::element_entry(&mut map, "_valueSet", item)?;
        }
        if !self.additional.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "additional", &self.additional)?;
        }
        if let Some(item) = &self.description {
            super::super::codec::value_entry(&mut map, "description", 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, "strength", &self.strength)?;
        if let Some(item) = &self.value_set {
            super::super::codec::value_entry(&mut map, "valueSet", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

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

/// Additional Bindings - more rules about the binding
///
/// Additional bindings that help applications implementing this element.
/// Additional bindings do not replace the main binding but provide more
/// information and/or context.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct ElementDefinitionBindingAdditional {
    /// Unique id for inter-element referencing
    ///
    /// 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. To make the use of extensions safe and
    /// managable, there is a strict set of governance applied to the definition and
    /// use of extensions. Though any implementer can 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>,
    /// Unique identifier so additional bindings to be matched across profiles
    ///
    /// A unique identifier for the additional binding within the element that
    /// allows additional bindings to be matched across profiles.
    pub key: Option<super::primitives::Id>,
    /// maximum | minimum | required | extensible | candidate | current |
    /// current-extensible | best-practice | preferred | ui | starter | component
    ///
    /// The use of this additional binding.
    pub purpose: super::primitives::Code,
    /// The value set for the additional binding
    ///
    /// The valueSet that is being bound for the purpose.
    pub value_set: super::primitives::Canonical,
    /// Documentation of the purpose of use of the binding
    ///
    /// Documentation of the purpose of use of the binding, providing additional
    /// information about how it is intended to be used.
    pub documentation: Option<super::primitives::Markdown>,
    /// Concise documentation - for summary tables.
    pub short_doco: Option<super::primitives::String>,
    /// Qualifies the usage - jurisdiction, gender, workflow status etc.
    ///
    /// Qualifies the usage of the binding. Typically bindings are qualified by
    /// jurisdiction, but they may also be qualified by gender, workflow status,
    /// clinical domain etc. The information to decide whether a usage context
    /// applies is usually outside the resource, determined by context, and this
    /// might present challenges for validation tooling.
    pub usage: Vec<super::usage_context::UsageContext>,
    /// Whether binding can applies to all repeats, or just one
    ///
    /// Whether the binding applies to all repeats, or just to any one of them. This
    /// is only relevant for elements that can repeat.
    pub any: Option<super::primitives::Boolean>,
}

impl super::super::codec::Json for ElementDefinitionBindingAdditional {
    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 let Some(item) = &self.key {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("key"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_key"), e);
            }
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.purpose)? {
            object.insert(std::string::String::from("purpose"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.purpose)? {
            object.insert(std::string::String::from("_purpose"), e);
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.value_set)? {
            object.insert(std::string::String::from("valueSet"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.value_set)? {
            object.insert(std::string::String::from("_valueSet"), 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 let Some(item) = &self.short_doco {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("shortDoco"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_shortDoco"), e);
            }
        }
        if !self.usage.is_empty() {
            let mut items = Vec::with_capacity(self.usage.len());
            for item in &self.usage {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("usage"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.any {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("any"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_any"), 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_key: Option<&super::super::codec::Value> = None;
        let mut raw_key_element: 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_value_set: Option<&super::super::codec::Value> = None;
        let mut raw_value_set_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_short_doco: Option<&super::super::codec::Value> = None;
        let mut raw_short_doco_element: Option<&super::super::codec::Value> = None;
        let mut raw_usage: Option<&super::super::codec::Value> = None;
        let mut raw_any: Option<&super::super::codec::Value> = None;
        let mut raw_any_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);
                }
                "key" => {
                    raw_key = Some(value);
                }
                "_key" => {
                    raw_key_element = Some(value);
                }
                "purpose" => {
                    raw_purpose = Some(value);
                }
                "_purpose" => {
                    raw_purpose_element = Some(value);
                }
                "valueSet" => {
                    raw_value_set = Some(value);
                }
                "_valueSet" => {
                    raw_value_set_element = Some(value);
                }
                "documentation" => {
                    raw_documentation = Some(value);
                }
                "_documentation" => {
                    raw_documentation_element = Some(value);
                }
                "shortDoco" => {
                    raw_short_doco = Some(value);
                }
                "_shortDoco" => {
                    raw_short_doco_element = Some(value);
                }
                "usage" => {
                    raw_usage = Some(value);
                }
                "any" => {
                    raw_any = Some(value);
                }
                "_any" => {
                    raw_any_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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        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 field_key = match (raw_key, raw_key_element) {
            (None, None) => None,
            (value, element) => Some(path.with("key", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_purpose = path.with("purpose", |path| {
            super::super::codec::Primitive::from_json_parts(raw_purpose, raw_purpose_element, path)
        })?;
        let field_value_set = path.with("valueSet", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_value_set,
                raw_value_set_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 field_short_doco = match (raw_short_doco, raw_short_doco_element) {
            (None, None) => None,
            (value, element) => Some(path.with("shortDoco", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_usage = Vec::new();
        if let Some(raw) = raw_usage {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_usage.push(path.with_index("usage", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_any = match (raw_any, raw_any_element) {
            (None, None) => None,
            (value, element) => Some(path.with("any", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            key: field_key,
            purpose: field_purpose,
            value_set: field_value_set,
            documentation: field_documentation,
            short_doco: field_short_doco,
            usage: field_usage,
            any: field_any,
        })
    }
}

impl serde::Serialize for ElementDefinitionBindingAdditional {
    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.any {
            super::super::codec::element_entry(&mut map, "_any", item)?;
        }
        if let Some(item) = &self.documentation {
            super::super::codec::element_entry(&mut map, "_documentation", item)?;
        }
        if let Some(item) = &self.key {
            super::super::codec::element_entry(&mut map, "_key", item)?;
        }
        super::super::codec::element_entry(&mut map, "_purpose", &self.purpose)?;
        if let Some(item) = &self.short_doco {
            super::super::codec::element_entry(&mut map, "_shortDoco", item)?;
        }
        super::super::codec::element_entry(&mut map, "_valueSet", &self.value_set)?;
        if let Some(item) = &self.any {
            super::super::codec::value_entry(&mut map, "any", 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)?;
        }
        if let Some(item) = &self.key {
            super::super::codec::value_entry(&mut map, "key", item)?;
        }
        super::super::codec::value_entry(&mut map, "purpose", &self.purpose)?;
        if let Some(item) = &self.short_doco {
            super::super::codec::value_entry(&mut map, "shortDoco", item)?;
        }
        if !self.usage.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "usage", &self.usage)?;
        }
        super::super::codec::value_entry(&mut map, "valueSet", &self.value_set)?;
        serde::ser::SerializeMap::end(map)
    }
}

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

/// Condition that must evaluate to true
///
/// Formal constraints such as co-occurrence and other constraints that can be
/// computationally evaluated within the context of the instance.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct ElementDefinitionConstraint {
    /// Unique id for inter-element referencing
    ///
    /// 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. To make the use of extensions safe and
    /// managable, there is a strict set of governance applied to the definition and
    /// use of extensions. Though any implementer can 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>,
    /// Target of 'condition' reference above
    ///
    /// Allows identification of which elements have their cardinalities impacted by
    /// the constraint. Will not be referenced for constraints that do not affect
    /// cardinality.
    pub key: super::primitives::Id,
    /// Why this constraint is necessary or appropriate
    ///
    /// Description of why this constraint is necessary or appropriate.
    pub requirements: Option<super::primitives::Markdown>,
    /// error | warning
    ///
    /// Identifies the impact constraint violation has on the conformance of the
    /// instance.
    pub severity: super::primitives::Code,
    /// Suppress warning or hint in profile
    ///
    /// If true, indicates that the warning or best practice guideline should be
    /// suppressed.
    pub suppress: Option<super::primitives::Boolean>,
    /// Human description of constraint
    ///
    /// Text that can be used to describe the constraint in messages identifying
    /// that the constraint has been violated.
    pub human: super::primitives::String,
    /// FHIRPath expression of constraint
    ///
    /// A \[FHIRPath\](fhirpath.html) expression of constraint that can be executed
    /// to see if this constraint is met.
    pub expression: Option<super::primitives::String>,
    /// Reference to original source of constraint
    ///
    /// A reference to the original source of the constraint, for traceability
    /// purposes.
    pub source: Option<super::primitives::Canonical>,
}

impl super::super::codec::Json for ElementDefinitionConstraint {
    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 let Some(v) = super::super::codec::Primitive::value_json(&self.key)? {
            object.insert(std::string::String::from("key"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.key)? {
            object.insert(std::string::String::from("_key"), e);
        }
        if let Some(item) = &self.requirements {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("requirements"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_requirements"), e);
            }
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.severity)? {
            object.insert(std::string::String::from("severity"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.severity)? {
            object.insert(std::string::String::from("_severity"), e);
        }
        if let Some(item) = &self.suppress {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("suppress"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_suppress"), e);
            }
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.human)? {
            object.insert(std::string::String::from("human"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.human)? {
            object.insert(std::string::String::from("_human"), e);
        }
        if let Some(item) = &self.expression {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("expression"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_expression"), e);
            }
        }
        if let Some(item) = &self.source {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("source"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_source"), 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_key: Option<&super::super::codec::Value> = None;
        let mut raw_key_element: Option<&super::super::codec::Value> = None;
        let mut raw_requirements: Option<&super::super::codec::Value> = None;
        let mut raw_requirements_element: Option<&super::super::codec::Value> = None;
        let mut raw_severity: Option<&super::super::codec::Value> = None;
        let mut raw_severity_element: Option<&super::super::codec::Value> = None;
        let mut raw_suppress: Option<&super::super::codec::Value> = None;
        let mut raw_suppress_element: Option<&super::super::codec::Value> = None;
        let mut raw_human: Option<&super::super::codec::Value> = None;
        let mut raw_human_element: Option<&super::super::codec::Value> = None;
        let mut raw_expression: Option<&super::super::codec::Value> = None;
        let mut raw_expression_element: Option<&super::super::codec::Value> = None;
        let mut raw_source: Option<&super::super::codec::Value> = None;
        let mut raw_source_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);
                }
                "key" => {
                    raw_key = Some(value);
                }
                "_key" => {
                    raw_key_element = Some(value);
                }
                "requirements" => {
                    raw_requirements = Some(value);
                }
                "_requirements" => {
                    raw_requirements_element = Some(value);
                }
                "severity" => {
                    raw_severity = Some(value);
                }
                "_severity" => {
                    raw_severity_element = Some(value);
                }
                "suppress" => {
                    raw_suppress = Some(value);
                }
                "_suppress" => {
                    raw_suppress_element = Some(value);
                }
                "human" => {
                    raw_human = Some(value);
                }
                "_human" => {
                    raw_human_element = Some(value);
                }
                "expression" => {
                    raw_expression = Some(value);
                }
                "_expression" => {
                    raw_expression_element = Some(value);
                }
                "source" => {
                    raw_source = Some(value);
                }
                "_source" => {
                    raw_source_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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        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 field_key = path.with("key", |path| {
            super::super::codec::Primitive::from_json_parts(raw_key, raw_key_element, path)
        })?;
        let field_requirements = match (raw_requirements, raw_requirements_element) {
            (None, None) => None,
            (value, element) => Some(path.with("requirements", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_severity = path.with("severity", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_severity,
                raw_severity_element,
                path,
            )
        })?;
        let field_suppress = match (raw_suppress, raw_suppress_element) {
            (None, None) => None,
            (value, element) => Some(path.with("suppress", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_human = path.with("human", |path| {
            super::super::codec::Primitive::from_json_parts(raw_human, raw_human_element, path)
        })?;
        let field_expression = match (raw_expression, raw_expression_element) {
            (None, None) => None,
            (value, element) => Some(path.with("expression", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_source = match (raw_source, raw_source_element) {
            (None, None) => None,
            (value, element) => Some(path.with("source", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            key: field_key,
            requirements: field_requirements,
            severity: field_severity,
            suppress: field_suppress,
            human: field_human,
            expression: field_expression,
            source: field_source,
        })
    }
}

impl serde::Serialize for ElementDefinitionConstraint {
    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.expression {
            super::super::codec::element_entry(&mut map, "_expression", item)?;
        }
        super::super::codec::element_entry(&mut map, "_human", &self.human)?;
        super::super::codec::element_entry(&mut map, "_key", &self.key)?;
        if let Some(item) = &self.requirements {
            super::super::codec::element_entry(&mut map, "_requirements", item)?;
        }
        super::super::codec::element_entry(&mut map, "_severity", &self.severity)?;
        if let Some(item) = &self.source {
            super::super::codec::element_entry(&mut map, "_source", item)?;
        }
        if let Some(item) = &self.suppress {
            super::super::codec::element_entry(&mut map, "_suppress", item)?;
        }
        if let Some(item) = &self.expression {
            super::super::codec::value_entry(&mut map, "expression", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        super::super::codec::value_entry(&mut map, "human", &self.human)?;
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        super::super::codec::value_entry(&mut map, "key", &self.key)?;
        if let Some(item) = &self.requirements {
            super::super::codec::value_entry(&mut map, "requirements", item)?;
        }
        super::super::codec::value_entry(&mut map, "severity", &self.severity)?;
        if let Some(item) = &self.source {
            super::super::codec::value_entry(&mut map, "source", item)?;
        }
        if let Some(item) = &self.suppress {
            super::super::codec::value_entry(&mut map, "suppress", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for ElementDefinitionConstraint {
    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("ElementDefinitionConstraint");
        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 \`ElementDefinition\`.
///
/// The value that should be used if there is no value stated in the instance
/// (e.g. 'if not otherwise specified, the abstract is false').
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ElementDefinitionDefaultValue {
    /// The `base64Binary` form.
    Base64Binary(super::primitives::Base64Binary),
    /// The `boolean` form.
    Boolean(super::primitives::Boolean),
    /// The `canonical` form.
    Canonical(super::primitives::Canonical),
    /// 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 `integer64` form.
    Integer64(super::primitives::Integer64),
    /// 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 `url` form.
    Url(super::primitives::Url),
    /// The `uuid` form.
    Uuid(super::primitives::Uuid),
    /// 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 `CodeableReference` form.
    CodeableReference(Box<super::codeable_reference::CodeableReference>),
    /// 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 `RatioRange` form.
    RatioRange(Box<super::ratio_range::RatioRange>),
    /// 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 `ContactDetail` form.
    ContactDetail(Box<super::contact_detail::ContactDetail>),
    /// The `DataRequirement` form.
    DataRequirement(Box<super::data_requirement::DataRequirement>),
    /// The `Expression` form.
    Expression(Box<super::expression::Expression>),
    /// The `ParameterDefinition` form.
    ParameterDefinition(Box<super::parameter_definition::ParameterDefinition>),
    /// The `RelatedArtifact` form.
    RelatedArtifact(Box<super::related_artifact::RelatedArtifact>),
    /// The `TriggerDefinition` form.
    TriggerDefinition(Box<super::trigger_definition::TriggerDefinition>),
    /// The `UsageContext` form.
    UsageContext(Box<super::usage_context::UsageContext>),
    /// The `Availability` form.
    Availability(Box<super::availability::Availability>),
    /// The `ExtendedContactDetail` form.
    ExtendedContactDetail(Box<super::extended_contact_detail::ExtendedContactDetail>),
    /// The `VirtualServiceDetail` form.
    VirtualServiceDetail(Box<super::virtual_service_detail::VirtualServiceDetail>),
    /// The `Dosage` form.
    Dosage(Box<super::dosage::Dosage>),
    /// The `Meta` form.
    Meta(Box<super::meta::Meta>),
}

impl ElementDefinitionDefaultValue {
    /// 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::Canonical(inner) => Ok((
                "Canonical",
                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::Integer64(inner) => Ok((
                "Integer64",
                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::Url(inner) => Ok((
                "Url",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Uuid(inner) => Ok((
                "Uuid",
                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::CodeableReference(inner) => Ok((
                "CodeableReference",
                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::RatioRange(inner) => Ok((
                "RatioRange",
                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::ContactDetail(inner) => Ok((
                "ContactDetail",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::DataRequirement(inner) => Ok((
                "DataRequirement",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Expression(inner) => Ok((
                "Expression",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::ParameterDefinition(inner) => Ok((
                "ParameterDefinition",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::RelatedArtifact(inner) => Ok((
                "RelatedArtifact",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::TriggerDefinition(inner) => Ok((
                "TriggerDefinition",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::UsageContext(inner) => Ok((
                "UsageContext",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Availability(inner) => Ok((
                "Availability",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::ExtendedContactDetail(inner) => Ok((
                "ExtendedContactDetail",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::VirtualServiceDetail(inner) => Ok((
                "VirtualServiceDetail",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Dosage(inner) => Ok((
                "Dosage",
                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)?,
            )),
            "Canonical" => Ok(Self::Canonical(
                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)?,
            )),
            "Integer64" => Ok(Self::Integer64(
                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,
            )?)),
            "Url" => Ok(Self::Url(super::super::codec::Primitive::from_json_parts(
                value, element, path,
            )?)),
            "Uuid" => Ok(Self::Uuid(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)))
            }
            "CodeableReference" => {
                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::CodeableReference(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)))
            }
            "RatioRange" => {
                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::RatioRange(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)))
            }
            "ContactDetail" => {
                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::ContactDetail(Box::new(inner)))
            }
            "DataRequirement" => {
                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::DataRequirement(Box::new(inner)))
            }
            "Expression" => {
                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::Expression(Box::new(inner)))
            }
            "ParameterDefinition" => {
                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::ParameterDefinition(Box::new(inner)))
            }
            "RelatedArtifact" => {
                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::RelatedArtifact(Box::new(inner)))
            }
            "TriggerDefinition" => {
                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::TriggerDefinition(Box::new(inner)))
            }
            "UsageContext" => {
                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::UsageContext(Box::new(inner)))
            }
            "Availability" => {
                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::Availability(Box::new(inner)))
            }
            "ExtendedContactDetail" => {
                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::ExtendedContactDetail(Box::new(inner)))
            }
            "VirtualServiceDetail" => {
                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::VirtualServiceDetail(Box::new(inner)))
            }
            "Dosage" => {
                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::Dosage(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)),
        }
    }
}

/// Example value (as defined for type)
///
/// A sample value for this element demonstrating the type of information that
/// would typically be found in the element.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ElementDefinitionExample {
    /// Unique id for inter-element referencing
    ///
    /// 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. To make the use of extensions safe and
    /// managable, there is a strict set of governance applied to the definition and
    /// use of extensions. Though any implementer can 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>,
    /// Describes the purpose of this example
    ///
    /// Describes the purpose of this example among the set of examples.
    pub label: super::primitives::String,
    /// Value of Example (one of allowed types)
    ///
    /// The actual value for the element, which must be one of the types allowed for
    /// this element.
    pub value: ElementDefinitionExampleValue,
}

impl super::super::codec::Json for ElementDefinitionExample {
    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 let Some(v) = super::super::codec::Primitive::value_json(&self.label)? {
            object.insert(std::string::String::from("label"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.label)? {
            object.insert(std::string::String::from("_label"), e);
        }
        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_label: Option<&super::super::codec::Value> = None;
        let mut raw_label_element: 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);
                }
                "label" => {
                    raw_label = Some(value);
                }
                "_label" => {
                    raw_label_element = Some(value);
                }
                "valueBase64Binary" => {
                    raw_value.value("Base64Binary", value, path)?;
                }
                "_valueBase64Binary" => {
                    raw_value.element("Base64Binary", value, path)?;
                }
                "valueBoolean" => {
                    raw_value.value("Boolean", value, path)?;
                }
                "_valueBoolean" => {
                    raw_value.element("Boolean", value, path)?;
                }
                "valueCanonical" => {
                    raw_value.value("Canonical", value, path)?;
                }
                "_valueCanonical" => {
                    raw_value.element("Canonical", value, path)?;
                }
                "valueCode" => {
                    raw_value.value("Code", value, path)?;
                }
                "_valueCode" => {
                    raw_value.element("Code", value, path)?;
                }
                "valueDate" => {
                    raw_value.value("Date", value, path)?;
                }
                "_valueDate" => {
                    raw_value.element("Date", value, path)?;
                }
                "valueDateTime" => {
                    raw_value.value("DateTime", value, path)?;
                }
                "_valueDateTime" => {
                    raw_value.element("DateTime", value, path)?;
                }
                "valueDecimal" => {
                    raw_value.value("Decimal", value, path)?;
                }
                "_valueDecimal" => {
                    raw_value.element("Decimal", value, path)?;
                }
                "valueId" => {
                    raw_value.value("Id", value, path)?;
                }
                "_valueId" => {
                    raw_value.element("Id", value, path)?;
                }
                "valueInstant" => {
                    raw_value.value("Instant", value, path)?;
                }
                "_valueInstant" => {
                    raw_value.element("Instant", value, path)?;
                }
                "valueInteger" => {
                    raw_value.value("Integer", value, path)?;
                }
                "_valueInteger" => {
                    raw_value.element("Integer", value, path)?;
                }
                "valueInteger64" => {
                    raw_value.value("Integer64", value, path)?;
                }
                "_valueInteger64" => {
                    raw_value.element("Integer64", value, path)?;
                }
                "valueMarkdown" => {
                    raw_value.value("Markdown", value, path)?;
                }
                "_valueMarkdown" => {
                    raw_value.element("Markdown", value, path)?;
                }
                "valueOid" => {
                    raw_value.value("Oid", value, path)?;
                }
                "_valueOid" => {
                    raw_value.element("Oid", value, path)?;
                }
                "valuePositiveInt" => {
                    raw_value.value("PositiveInt", value, path)?;
                }
                "_valuePositiveInt" => {
                    raw_value.element("PositiveInt", value, path)?;
                }
                "valueString" => {
                    raw_value.value("String", value, path)?;
                }
                "_valueString" => {
                    raw_value.element("String", value, path)?;
                }
                "valueTime" => {
                    raw_value.value("Time", value, path)?;
                }
                "_valueTime" => {
                    raw_value.element("Time", value, path)?;
                }
                "valueUnsignedInt" => {
                    raw_value.value("UnsignedInt", value, path)?;
                }
                "_valueUnsignedInt" => {
                    raw_value.element("UnsignedInt", value, path)?;
                }
                "valueUri" => {
                    raw_value.value("Uri", value, path)?;
                }
                "_valueUri" => {
                    raw_value.element("Uri", value, path)?;
                }
                "valueUrl" => {
                    raw_value.value("Url", value, path)?;
                }
                "_valueUrl" => {
                    raw_value.element("Url", value, path)?;
                }
                "valueUuid" => {
                    raw_value.value("Uuid", value, path)?;
                }
                "_valueUuid" => {
                    raw_value.element("Uuid", value, path)?;
                }
                "valueAddress" => {
                    raw_value.value("Address", value, path)?;
                }
                "_valueAddress" => {
                    raw_value.element("Address", value, path)?;
                }
                "valueAge" => {
                    raw_value.value("Age", value, path)?;
                }
                "_valueAge" => {
                    raw_value.element("Age", value, path)?;
                }
                "valueAnnotation" => {
                    raw_value.value("Annotation", value, path)?;
                }
                "_valueAnnotation" => {
                    raw_value.element("Annotation", value, path)?;
                }
                "valueAttachment" => {
                    raw_value.value("Attachment", value, path)?;
                }
                "_valueAttachment" => {
                    raw_value.element("Attachment", value, path)?;
                }
                "valueCodeableConcept" => {
                    raw_value.value("CodeableConcept", value, path)?;
                }
                "_valueCodeableConcept" => {
                    raw_value.element("CodeableConcept", value, path)?;
                }
                "valueCodeableReference" => {
                    raw_value.value("CodeableReference", value, path)?;
                }
                "_valueCodeableReference" => {
                    raw_value.element("CodeableReference", value, path)?;
                }
                "valueCoding" => {
                    raw_value.value("Coding", value, path)?;
                }
                "_valueCoding" => {
                    raw_value.element("Coding", value, path)?;
                }
                "valueContactPoint" => {
                    raw_value.value("ContactPoint", value, path)?;
                }
                "_valueContactPoint" => {
                    raw_value.element("ContactPoint", value, path)?;
                }
                "valueCount" => {
                    raw_value.value("Count", value, path)?;
                }
                "_valueCount" => {
                    raw_value.element("Count", value, path)?;
                }
                "valueDistance" => {
                    raw_value.value("Distance", value, path)?;
                }
                "_valueDistance" => {
                    raw_value.element("Distance", value, path)?;
                }
                "valueDuration" => {
                    raw_value.value("Duration", value, path)?;
                }
                "_valueDuration" => {
                    raw_value.element("Duration", value, path)?;
                }
                "valueHumanName" => {
                    raw_value.value("HumanName", value, path)?;
                }
                "_valueHumanName" => {
                    raw_value.element("HumanName", value, path)?;
                }
                "valueIdentifier" => {
                    raw_value.value("Identifier", value, path)?;
                }
                "_valueIdentifier" => {
                    raw_value.element("Identifier", value, path)?;
                }
                "valueMoney" => {
                    raw_value.value("Money", value, path)?;
                }
                "_valueMoney" => {
                    raw_value.element("Money", value, path)?;
                }
                "valuePeriod" => {
                    raw_value.value("Period", value, path)?;
                }
                "_valuePeriod" => {
                    raw_value.element("Period", value, path)?;
                }
                "valueQuantity" => {
                    raw_value.value("Quantity", value, path)?;
                }
                "_valueQuantity" => {
                    raw_value.element("Quantity", value, path)?;
                }
                "valueRange" => {
                    raw_value.value("Range", value, path)?;
                }
                "_valueRange" => {
                    raw_value.element("Range", value, path)?;
                }
                "valueRatio" => {
                    raw_value.value("Ratio", value, path)?;
                }
                "_valueRatio" => {
                    raw_value.element("Ratio", value, path)?;
                }
                "valueRatioRange" => {
                    raw_value.value("RatioRange", value, path)?;
                }
                "_valueRatioRange" => {
                    raw_value.element("RatioRange", value, path)?;
                }
                "valueReference" => {
                    raw_value.value("Reference", value, path)?;
                }
                "_valueReference" => {
                    raw_value.element("Reference", value, path)?;
                }
                "valueSampledData" => {
                    raw_value.value("SampledData", value, path)?;
                }
                "_valueSampledData" => {
                    raw_value.element("SampledData", value, path)?;
                }
                "valueSignature" => {
                    raw_value.value("Signature", value, path)?;
                }
                "_valueSignature" => {
                    raw_value.element("Signature", value, path)?;
                }
                "valueTiming" => {
                    raw_value.value("Timing", value, path)?;
                }
                "_valueTiming" => {
                    raw_value.element("Timing", value, path)?;
                }
                "valueContactDetail" => {
                    raw_value.value("ContactDetail", value, path)?;
                }
                "_valueContactDetail" => {
                    raw_value.element("ContactDetail", value, path)?;
                }
                "valueDataRequirement" => {
                    raw_value.value("DataRequirement", value, path)?;
                }
                "_valueDataRequirement" => {
                    raw_value.element("DataRequirement", value, path)?;
                }
                "valueExpression" => {
                    raw_value.value("Expression", value, path)?;
                }
                "_valueExpression" => {
                    raw_value.element("Expression", value, path)?;
                }
                "valueParameterDefinition" => {
                    raw_value.value("ParameterDefinition", value, path)?;
                }
                "_valueParameterDefinition" => {
                    raw_value.element("ParameterDefinition", value, path)?;
                }
                "valueRelatedArtifact" => {
                    raw_value.value("RelatedArtifact", value, path)?;
                }
                "_valueRelatedArtifact" => {
                    raw_value.element("RelatedArtifact", value, path)?;
                }
                "valueTriggerDefinition" => {
                    raw_value.value("TriggerDefinition", value, path)?;
                }
                "_valueTriggerDefinition" => {
                    raw_value.element("TriggerDefinition", value, path)?;
                }
                "valueUsageContext" => {
                    raw_value.value("UsageContext", value, path)?;
                }
                "_valueUsageContext" => {
                    raw_value.element("UsageContext", value, path)?;
                }
                "valueAvailability" => {
                    raw_value.value("Availability", value, path)?;
                }
                "_valueAvailability" => {
                    raw_value.element("Availability", value, path)?;
                }
                "valueExtendedContactDetail" => {
                    raw_value.value("ExtendedContactDetail", value, path)?;
                }
                "_valueExtendedContactDetail" => {
                    raw_value.element("ExtendedContactDetail", value, path)?;
                }
                "valueVirtualServiceDetail" => {
                    raw_value.value("VirtualServiceDetail", value, path)?;
                }
                "_valueVirtualServiceDetail" => {
                    raw_value.element("VirtualServiceDetail", value, path)?;
                }
                "valueDosage" => {
                    raw_value.value("Dosage", value, path)?;
                }
                "_valueDosage" => {
                    raw_value.element("Dosage", value, path)?;
                }
                "valueMeta" => {
                    raw_value.value("Meta", value, path)?;
                }
                "_valueMeta" => {
                    raw_value.element("Meta", 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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        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 field_label = path.with("label", |path| {
            super::super::codec::Primitive::from_json_parts(raw_label, raw_label_element, path)
        })?;
        let field_value = path.with("value", |path| {
            let suffix = raw_value
                .suffix
                .ok_or_else(|| path.error(super::super::codec::DecodeErrorKind::MissingProperty))?;
            ElementDefinitionExampleValue::from_json_parts(
                suffix,
                raw_value.value,
                raw_value.element,
                path,
            )
        })?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            label: field_label,
            value: field_value,
        })
    }
}

impl serde::Serialize for ElementDefinitionExample {
    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, "_label", &self.label)?;
        match &self.value {
            ElementDefinitionExampleValue::Base64Binary(inner) => {
                super::super::codec::element_entry(&mut map, "_valueBase64Binary", inner)?;
            }
            ElementDefinitionExampleValue::Boolean(inner) => {
                super::super::codec::element_entry(&mut map, "_valueBoolean", inner)?;
            }
            ElementDefinitionExampleValue::Canonical(inner) => {
                super::super::codec::element_entry(&mut map, "_valueCanonical", inner)?;
            }
            ElementDefinitionExampleValue::Code(inner) => {
                super::super::codec::element_entry(&mut map, "_valueCode", inner)?;
            }
            ElementDefinitionExampleValue::Date(inner) => {
                super::super::codec::element_entry(&mut map, "_valueDate", inner)?;
            }
            ElementDefinitionExampleValue::DateTime(inner) => {
                super::super::codec::element_entry(&mut map, "_valueDateTime", inner)?;
            }
            ElementDefinitionExampleValue::Decimal(inner) => {
                super::super::codec::element_entry(&mut map, "_valueDecimal", inner)?;
            }
            ElementDefinitionExampleValue::Id(inner) => {
                super::super::codec::element_entry(&mut map, "_valueId", inner)?;
            }
            ElementDefinitionExampleValue::Instant(inner) => {
                super::super::codec::element_entry(&mut map, "_valueInstant", inner)?;
            }
            ElementDefinitionExampleValue::Integer(inner) => {
                super::super::codec::element_entry(&mut map, "_valueInteger", inner)?;
            }
            ElementDefinitionExampleValue::Integer64(inner) => {
                super::super::codec::element_entry(&mut map, "_valueInteger64", inner)?;
            }
            ElementDefinitionExampleValue::Markdown(inner) => {
                super::super::codec::element_entry(&mut map, "_valueMarkdown", inner)?;
            }
            ElementDefinitionExampleValue::Oid(inner) => {
                super::super::codec::element_entry(&mut map, "_valueOid", inner)?;
            }
            ElementDefinitionExampleValue::PositiveInt(inner) => {
                super::super::codec::element_entry(&mut map, "_valuePositiveInt", inner)?;
            }
            ElementDefinitionExampleValue::String(inner) => {
                super::super::codec::element_entry(&mut map, "_valueString", inner)?;
            }
            ElementDefinitionExampleValue::Time(inner) => {
                super::super::codec::element_entry(&mut map, "_valueTime", inner)?;
            }
            ElementDefinitionExampleValue::UnsignedInt(inner) => {
                super::super::codec::element_entry(&mut map, "_valueUnsignedInt", inner)?;
            }
            ElementDefinitionExampleValue::Uri(inner) => {
                super::super::codec::element_entry(&mut map, "_valueUri", inner)?;
            }
            ElementDefinitionExampleValue::Url(inner) => {
                super::super::codec::element_entry(&mut map, "_valueUrl", inner)?;
            }
            ElementDefinitionExampleValue::Uuid(inner) => {
                super::super::codec::element_entry(&mut map, "_valueUuid", 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)?;
        }
        super::super::codec::value_entry(&mut map, "label", &self.label)?;
        match &self.value {
            ElementDefinitionExampleValue::Address(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueAddress",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::Age(inner) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "valueAge", inner.as_ref())?;
            }
            ElementDefinitionExampleValue::Annotation(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueAnnotation",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::Attachment(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueAttachment",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::Availability(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueAvailability",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::Base64Binary(inner) => {
                super::super::codec::value_entry(&mut map, "valueBase64Binary", inner)?;
            }
            ElementDefinitionExampleValue::Boolean(inner) => {
                super::super::codec::value_entry(&mut map, "valueBoolean", inner)?;
            }
            ElementDefinitionExampleValue::Canonical(inner) => {
                super::super::codec::value_entry(&mut map, "valueCanonical", inner)?;
            }
            ElementDefinitionExampleValue::Code(inner) => {
                super::super::codec::value_entry(&mut map, "valueCode", inner)?;
            }
            ElementDefinitionExampleValue::CodeableConcept(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueCodeableConcept",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::CodeableReference(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueCodeableReference",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::Coding(inner) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "valueCoding", inner.as_ref())?;
            }
            ElementDefinitionExampleValue::ContactDetail(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueContactDetail",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::ContactPoint(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueContactPoint",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::Count(inner) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "valueCount", inner.as_ref())?;
            }
            ElementDefinitionExampleValue::DataRequirement(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueDataRequirement",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::Date(inner) => {
                super::super::codec::value_entry(&mut map, "valueDate", inner)?;
            }
            ElementDefinitionExampleValue::DateTime(inner) => {
                super::super::codec::value_entry(&mut map, "valueDateTime", inner)?;
            }
            ElementDefinitionExampleValue::Decimal(inner) => {
                super::super::codec::value_entry(&mut map, "valueDecimal", inner)?;
            }
            ElementDefinitionExampleValue::Distance(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueDistance",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::Dosage(inner) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "valueDosage", inner.as_ref())?;
            }
            ElementDefinitionExampleValue::Duration(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueDuration",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::Expression(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueExpression",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::ExtendedContactDetail(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueExtendedContactDetail",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::HumanName(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueHumanName",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::Id(inner) => {
                super::super::codec::value_entry(&mut map, "valueId", inner)?;
            }
            ElementDefinitionExampleValue::Identifier(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueIdentifier",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::Instant(inner) => {
                super::super::codec::value_entry(&mut map, "valueInstant", inner)?;
            }
            ElementDefinitionExampleValue::Integer(inner) => {
                super::super::codec::value_entry(&mut map, "valueInteger", inner)?;
            }
            ElementDefinitionExampleValue::Integer64(inner) => {
                super::super::codec::value_entry(&mut map, "valueInteger64", inner)?;
            }
            ElementDefinitionExampleValue::Markdown(inner) => {
                super::super::codec::value_entry(&mut map, "valueMarkdown", inner)?;
            }
            ElementDefinitionExampleValue::Meta(inner) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "valueMeta", inner.as_ref())?;
            }
            ElementDefinitionExampleValue::Money(inner) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "valueMoney", inner.as_ref())?;
            }
            ElementDefinitionExampleValue::Oid(inner) => {
                super::super::codec::value_entry(&mut map, "valueOid", inner)?;
            }
            ElementDefinitionExampleValue::ParameterDefinition(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueParameterDefinition",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::Period(inner) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "valuePeriod", inner.as_ref())?;
            }
            ElementDefinitionExampleValue::PositiveInt(inner) => {
                super::super::codec::value_entry(&mut map, "valuePositiveInt", inner)?;
            }
            ElementDefinitionExampleValue::Quantity(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueQuantity",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::Range(inner) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "valueRange", inner.as_ref())?;
            }
            ElementDefinitionExampleValue::Ratio(inner) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "valueRatio", inner.as_ref())?;
            }
            ElementDefinitionExampleValue::RatioRange(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueRatioRange",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::Reference(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueReference",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::RelatedArtifact(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueRelatedArtifact",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::SampledData(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueSampledData",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::Signature(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueSignature",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::String(inner) => {
                super::super::codec::value_entry(&mut map, "valueString", inner)?;
            }
            ElementDefinitionExampleValue::Time(inner) => {
                super::super::codec::value_entry(&mut map, "valueTime", inner)?;
            }
            ElementDefinitionExampleValue::Timing(inner) => {
                serde::ser::SerializeMap::serialize_entry(&mut map, "valueTiming", inner.as_ref())?;
            }
            ElementDefinitionExampleValue::TriggerDefinition(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueTriggerDefinition",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::UnsignedInt(inner) => {
                super::super::codec::value_entry(&mut map, "valueUnsignedInt", inner)?;
            }
            ElementDefinitionExampleValue::Uri(inner) => {
                super::super::codec::value_entry(&mut map, "valueUri", inner)?;
            }
            ElementDefinitionExampleValue::Url(inner) => {
                super::super::codec::value_entry(&mut map, "valueUrl", inner)?;
            }
            ElementDefinitionExampleValue::UsageContext(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueUsageContext",
                    inner.as_ref(),
                )?;
            }
            ElementDefinitionExampleValue::Uuid(inner) => {
                super::super::codec::value_entry(&mut map, "valueUuid", inner)?;
            }
            ElementDefinitionExampleValue::VirtualServiceDetail(inner) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "valueVirtualServiceDetail",
                    inner.as_ref(),
                )?;
            }
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for ElementDefinitionExample {
    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("ElementDefinitionExample");
        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 \`ElementDefinitionExample\`.
///
/// The actual value for the element, which must be one of the types allowed for
/// this element.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ElementDefinitionExampleValue {
    /// The `base64Binary` form.
    Base64Binary(super::primitives::Base64Binary),
    /// The `boolean` form.
    Boolean(super::primitives::Boolean),
    /// The `canonical` form.
    Canonical(super::primitives::Canonical),
    /// 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 `integer64` form.
    Integer64(super::primitives::Integer64),
    /// 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 `url` form.
    Url(super::primitives::Url),
    /// The `uuid` form.
    Uuid(super::primitives::Uuid),
    /// 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 `CodeableReference` form.
    CodeableReference(Box<super::codeable_reference::CodeableReference>),
    /// 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 `RatioRange` form.
    RatioRange(Box<super::ratio_range::RatioRange>),
    /// 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 `ContactDetail` form.
    ContactDetail(Box<super::contact_detail::ContactDetail>),
    /// The `DataRequirement` form.
    DataRequirement(Box<super::data_requirement::DataRequirement>),
    /// The `Expression` form.
    Expression(Box<super::expression::Expression>),
    /// The `ParameterDefinition` form.
    ParameterDefinition(Box<super::parameter_definition::ParameterDefinition>),
    /// The `RelatedArtifact` form.
    RelatedArtifact(Box<super::related_artifact::RelatedArtifact>),
    /// The `TriggerDefinition` form.
    TriggerDefinition(Box<super::trigger_definition::TriggerDefinition>),
    /// The `UsageContext` form.
    UsageContext(Box<super::usage_context::UsageContext>),
    /// The `Availability` form.
    Availability(Box<super::availability::Availability>),
    /// The `ExtendedContactDetail` form.
    ExtendedContactDetail(Box<super::extended_contact_detail::ExtendedContactDetail>),
    /// The `VirtualServiceDetail` form.
    VirtualServiceDetail(Box<super::virtual_service_detail::VirtualServiceDetail>),
    /// The `Dosage` form.
    Dosage(Box<super::dosage::Dosage>),
    /// The `Meta` form.
    Meta(Box<super::meta::Meta>),
}

impl ElementDefinitionExampleValue {
    /// 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::Canonical(inner) => Ok((
                "Canonical",
                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::Integer64(inner) => Ok((
                "Integer64",
                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::Url(inner) => Ok((
                "Url",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Uuid(inner) => Ok((
                "Uuid",
                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::CodeableReference(inner) => Ok((
                "CodeableReference",
                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::RatioRange(inner) => Ok((
                "RatioRange",
                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::ContactDetail(inner) => Ok((
                "ContactDetail",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::DataRequirement(inner) => Ok((
                "DataRequirement",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Expression(inner) => Ok((
                "Expression",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::ParameterDefinition(inner) => Ok((
                "ParameterDefinition",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::RelatedArtifact(inner) => Ok((
                "RelatedArtifact",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::TriggerDefinition(inner) => Ok((
                "TriggerDefinition",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::UsageContext(inner) => Ok((
                "UsageContext",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Availability(inner) => Ok((
                "Availability",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::ExtendedContactDetail(inner) => Ok((
                "ExtendedContactDetail",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::VirtualServiceDetail(inner) => Ok((
                "VirtualServiceDetail",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Dosage(inner) => Ok((
                "Dosage",
                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)?,
            )),
            "Canonical" => Ok(Self::Canonical(
                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)?,
            )),
            "Integer64" => Ok(Self::Integer64(
                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,
            )?)),
            "Url" => Ok(Self::Url(super::super::codec::Primitive::from_json_parts(
                value, element, path,
            )?)),
            "Uuid" => Ok(Self::Uuid(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)))
            }
            "CodeableReference" => {
                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::CodeableReference(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)))
            }
            "RatioRange" => {
                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::RatioRange(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)))
            }
            "ContactDetail" => {
                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::ContactDetail(Box::new(inner)))
            }
            "DataRequirement" => {
                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::DataRequirement(Box::new(inner)))
            }
            "Expression" => {
                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::Expression(Box::new(inner)))
            }
            "ParameterDefinition" => {
                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::ParameterDefinition(Box::new(inner)))
            }
            "RelatedArtifact" => {
                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::RelatedArtifact(Box::new(inner)))
            }
            "TriggerDefinition" => {
                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::TriggerDefinition(Box::new(inner)))
            }
            "UsageContext" => {
                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::UsageContext(Box::new(inner)))
            }
            "Availability" => {
                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::Availability(Box::new(inner)))
            }
            "ExtendedContactDetail" => {
                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::ExtendedContactDetail(Box::new(inner)))
            }
            "VirtualServiceDetail" => {
                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::VirtualServiceDetail(Box::new(inner)))
            }
            "Dosage" => {
                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::Dosage(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)),
        }
    }
}

/// The \`fixed\[x\]\` choice of \`ElementDefinition\`.
///
/// Specifies a value that SHALL be exactly the value for this element in the
/// instance, if present. For purposes of comparison, non-significant whitespace
/// is ignored, and all values must be an exact match (case and accent
/// sensitive). Missing elements/attributes must also be missing.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ElementDefinitionFixed {
    /// The `base64Binary` form.
    Base64Binary(super::primitives::Base64Binary),
    /// The `boolean` form.
    Boolean(super::primitives::Boolean),
    /// The `canonical` form.
    Canonical(super::primitives::Canonical),
    /// 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 `integer64` form.
    Integer64(super::primitives::Integer64),
    /// 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 `url` form.
    Url(super::primitives::Url),
    /// The `uuid` form.
    Uuid(super::primitives::Uuid),
    /// 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 `CodeableReference` form.
    CodeableReference(Box<super::codeable_reference::CodeableReference>),
    /// 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 `RatioRange` form.
    RatioRange(Box<super::ratio_range::RatioRange>),
    /// 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 `ContactDetail` form.
    ContactDetail(Box<super::contact_detail::ContactDetail>),
    /// The `DataRequirement` form.
    DataRequirement(Box<super::data_requirement::DataRequirement>),
    /// The `Expression` form.
    Expression(Box<super::expression::Expression>),
    /// The `ParameterDefinition` form.
    ParameterDefinition(Box<super::parameter_definition::ParameterDefinition>),
    /// The `RelatedArtifact` form.
    RelatedArtifact(Box<super::related_artifact::RelatedArtifact>),
    /// The `TriggerDefinition` form.
    TriggerDefinition(Box<super::trigger_definition::TriggerDefinition>),
    /// The `UsageContext` form.
    UsageContext(Box<super::usage_context::UsageContext>),
    /// The `Availability` form.
    Availability(Box<super::availability::Availability>),
    /// The `ExtendedContactDetail` form.
    ExtendedContactDetail(Box<super::extended_contact_detail::ExtendedContactDetail>),
    /// The `VirtualServiceDetail` form.
    VirtualServiceDetail(Box<super::virtual_service_detail::VirtualServiceDetail>),
    /// The `Dosage` form.
    Dosage(Box<super::dosage::Dosage>),
    /// The `Meta` form.
    Meta(Box<super::meta::Meta>),
}

impl ElementDefinitionFixed {
    /// 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::Canonical(inner) => Ok((
                "Canonical",
                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::Integer64(inner) => Ok((
                "Integer64",
                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::Url(inner) => Ok((
                "Url",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Uuid(inner) => Ok((
                "Uuid",
                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::CodeableReference(inner) => Ok((
                "CodeableReference",
                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::RatioRange(inner) => Ok((
                "RatioRange",
                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::ContactDetail(inner) => Ok((
                "ContactDetail",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::DataRequirement(inner) => Ok((
                "DataRequirement",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Expression(inner) => Ok((
                "Expression",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::ParameterDefinition(inner) => Ok((
                "ParameterDefinition",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::RelatedArtifact(inner) => Ok((
                "RelatedArtifact",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::TriggerDefinition(inner) => Ok((
                "TriggerDefinition",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::UsageContext(inner) => Ok((
                "UsageContext",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Availability(inner) => Ok((
                "Availability",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::ExtendedContactDetail(inner) => Ok((
                "ExtendedContactDetail",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::VirtualServiceDetail(inner) => Ok((
                "VirtualServiceDetail",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Dosage(inner) => Ok((
                "Dosage",
                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)?,
            )),
            "Canonical" => Ok(Self::Canonical(
                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)?,
            )),
            "Integer64" => Ok(Self::Integer64(
                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,
            )?)),
            "Url" => Ok(Self::Url(super::super::codec::Primitive::from_json_parts(
                value, element, path,
            )?)),
            "Uuid" => Ok(Self::Uuid(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)))
            }
            "CodeableReference" => {
                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::CodeableReference(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)))
            }
            "RatioRange" => {
                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::RatioRange(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)))
            }
            "ContactDetail" => {
                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::ContactDetail(Box::new(inner)))
            }
            "DataRequirement" => {
                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::DataRequirement(Box::new(inner)))
            }
            "Expression" => {
                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::Expression(Box::new(inner)))
            }
            "ParameterDefinition" => {
                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::ParameterDefinition(Box::new(inner)))
            }
            "RelatedArtifact" => {
                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::RelatedArtifact(Box::new(inner)))
            }
            "TriggerDefinition" => {
                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::TriggerDefinition(Box::new(inner)))
            }
            "UsageContext" => {
                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::UsageContext(Box::new(inner)))
            }
            "Availability" => {
                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::Availability(Box::new(inner)))
            }
            "ExtendedContactDetail" => {
                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::ExtendedContactDetail(Box::new(inner)))
            }
            "VirtualServiceDetail" => {
                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::VirtualServiceDetail(Box::new(inner)))
            }
            "Dosage" => {
                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::Dosage(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)),
        }
    }
}

/// Map element to another set of definitions
///
/// Identifies a concept from an external specification that roughly corresponds
/// to this element.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct ElementDefinitionMapping {
    /// Unique id for inter-element referencing
    ///
    /// 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. To make the use of extensions safe and
    /// managable, there is a strict set of governance applied to the definition and
    /// use of extensions. Though any implementer can 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>,
    /// Reference to mapping declaration
    ///
    /// An internal reference to the definition of a mapping.
    pub identity: super::primitives::Id,
    /// Computable language of mapping
    ///
    /// Identifies the computable language in which mapping.map is expressed.
    pub language: Option<super::primitives::Code>,
    /// Details of the mapping
    ///
    /// Expresses what part of the target specification corresponds to this element.
    pub map: super::primitives::String,
    /// Comments about the mapping or its use
    ///
    /// Comments that provide information about the mapping or its use.
    pub comment: Option<super::primitives::Markdown>,
}

impl super::super::codec::Json for ElementDefinitionMapping {
    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 let Some(v) = super::super::codec::Primitive::value_json(&self.identity)? {
            object.insert(std::string::String::from("identity"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.identity)? {
            object.insert(std::string::String::from("_identity"), 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(v) = super::super::codec::Primitive::value_json(&self.map)? {
            object.insert(std::string::String::from("map"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.map)? {
            object.insert(std::string::String::from("_map"), e);
        }
        if let Some(item) = &self.comment {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("comment"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_comment"), 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_identity: Option<&super::super::codec::Value> = None;
        let mut raw_identity_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_map: Option<&super::super::codec::Value> = None;
        let mut raw_map_element: Option<&super::super::codec::Value> = None;
        let mut raw_comment: Option<&super::super::codec::Value> = None;
        let mut raw_comment_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);
                }
                "identity" => {
                    raw_identity = Some(value);
                }
                "_identity" => {
                    raw_identity_element = Some(value);
                }
                "language" => {
                    raw_language = Some(value);
                }
                "_language" => {
                    raw_language_element = Some(value);
                }
                "map" => {
                    raw_map = Some(value);
                }
                "_map" => {
                    raw_map_element = Some(value);
                }
                "comment" => {
                    raw_comment = Some(value);
                }
                "_comment" => {
                    raw_comment_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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        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 field_identity = path.with("identity", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_identity,
                raw_identity_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_map = path.with("map", |path| {
            super::super::codec::Primitive::from_json_parts(raw_map, raw_map_element, path)
        })?;
        let field_comment = match (raw_comment, raw_comment_element) {
            (None, None) => None,
            (value, element) => Some(path.with("comment", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            identity: field_identity,
            language: field_language,
            map: field_map,
            comment: field_comment,
        })
    }
}

impl serde::Serialize for ElementDefinitionMapping {
    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.comment {
            super::super::codec::element_entry(&mut map, "_comment", item)?;
        }
        super::super::codec::element_entry(&mut map, "_identity", &self.identity)?;
        if let Some(item) = &self.language {
            super::super::codec::element_entry(&mut map, "_language", item)?;
        }
        super::super::codec::element_entry(&mut map, "_map", &self.map)?;
        if let Some(item) = &self.comment {
            super::super::codec::value_entry(&mut map, "comment", 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, "identity", &self.identity)?;
        if let Some(item) = &self.language {
            super::super::codec::value_entry(&mut map, "language", item)?;
        }
        super::super::codec::value_entry(&mut map, "map", &self.map)?;
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for ElementDefinitionMapping {
    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("ElementDefinitionMapping");
        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 \`maxValue\[x\]\` choice of \`ElementDefinition\`.
///
/// The maximum allowed value for the element. The value is inclusive. This is
/// allowed for the types date, dateTime, instant, time, decimal, integer, and
/// Quantity.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ElementDefinitionMaxValue {
    /// The `date` form.
    Date(super::primitives::Date),
    /// The `dateTime` form.
    DateTime(super::primitives::DateTime),
    /// The `instant` form.
    Instant(super::primitives::Instant),
    /// The `time` form.
    Time(super::primitives::Time),
    /// The `decimal` form.
    Decimal(super::primitives::Decimal),
    /// The `integer` form.
    Integer(super::primitives::Integer),
    /// The `integer64` form.
    Integer64(super::primitives::Integer64),
    /// The `positiveInt` form.
    PositiveInt(super::primitives::PositiveInt),
    /// The `unsignedInt` form.
    UnsignedInt(super::primitives::UnsignedInt),
    /// The `Quantity` form.
    Quantity(Box<super::quantity::Quantity>),
}

impl ElementDefinitionMaxValue {
    /// 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::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::Instant(inner) => Ok((
                "Instant",
                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::Decimal(inner) => Ok((
                "Decimal",
                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::Integer64(inner) => Ok((
                "Integer64",
                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::UnsignedInt(inner) => Ok((
                "UnsignedInt",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Quantity(inner) => Ok((
                "Quantity",
                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 {
            "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)?,
            )),
            "Instant" => Ok(Self::Instant(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Time" => Ok(Self::Time(super::super::codec::Primitive::from_json_parts(
                value, element, path,
            )?)),
            "Decimal" => Ok(Self::Decimal(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Integer" => Ok(Self::Integer(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Integer64" => Ok(Self::Integer64(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "PositiveInt" => Ok(Self::PositiveInt(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "UnsignedInt" => Ok(Self::UnsignedInt(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "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)))
            }
            _ => Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty)),
        }
    }
}

/// The \`minValue\[x\]\` choice of \`ElementDefinition\`.
///
/// The minimum allowed value for the element. The value is inclusive. This is
/// allowed for the types date, dateTime, instant, time, decimal, integer, and
/// Quantity.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ElementDefinitionMinValue {
    /// The `date` form.
    Date(super::primitives::Date),
    /// The `dateTime` form.
    DateTime(super::primitives::DateTime),
    /// The `instant` form.
    Instant(super::primitives::Instant),
    /// The `time` form.
    Time(super::primitives::Time),
    /// The `decimal` form.
    Decimal(super::primitives::Decimal),
    /// The `integer` form.
    Integer(super::primitives::Integer),
    /// The `integer64` form.
    Integer64(super::primitives::Integer64),
    /// The `positiveInt` form.
    PositiveInt(super::primitives::PositiveInt),
    /// The `unsignedInt` form.
    UnsignedInt(super::primitives::UnsignedInt),
    /// The `Quantity` form.
    Quantity(Box<super::quantity::Quantity>),
}

impl ElementDefinitionMinValue {
    /// 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::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::Instant(inner) => Ok((
                "Instant",
                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::Decimal(inner) => Ok((
                "Decimal",
                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::Integer64(inner) => Ok((
                "Integer64",
                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::UnsignedInt(inner) => Ok((
                "UnsignedInt",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Quantity(inner) => Ok((
                "Quantity",
                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 {
            "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)?,
            )),
            "Instant" => Ok(Self::Instant(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Time" => Ok(Self::Time(super::super::codec::Primitive::from_json_parts(
                value, element, path,
            )?)),
            "Decimal" => Ok(Self::Decimal(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Integer" => Ok(Self::Integer(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Integer64" => Ok(Self::Integer64(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "PositiveInt" => Ok(Self::PositiveInt(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "UnsignedInt" => Ok(Self::UnsignedInt(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "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)))
            }
            _ => Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty)),
        }
    }
}

/// The \`pattern\[x\]\` choice of \`ElementDefinition\`.
///
/// Specifies a value that each occurrence of the element in the instance SHALL
/// follow - that is, any value in the pattern must be found in the instance, if
/// the element has a value. Other additional values may be found too. This is
/// effectively constraint by example. When pattern\[x\] is used to constrain a
/// primitive, it means that the value provided in the pattern\[x\] must match
/// the instance value exactly. When an element within a pattern\[x\] is used to
/// constrain an array, it means that each element provided in the pattern\[x\]
/// must (recursively) match at least one element from the instance array. When
/// pattern\[x\] is used to constrain a complex object, it means that each
/// property in the pattern must be present in the complex object, and its value
/// must recursively match -- i.e., 1. If primitive: it must match exactly the
/// pattern value 2. If a complex object: it must match (recursively) the
/// pattern value 3. If an array: it must match (recursively) the pattern value
/// If a pattern\[x\] is declared on a repeating element, the pattern applies to
/// all repetitions. If the desire is for a pattern to apply to only one element
/// or a subset of elements, slicing must be used. See \[Examples of
/// Patterns\](elementdefinition-examples.html\#pattern-examples) for examples
/// of pattern usage and the effect it will have.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ElementDefinitionPattern {
    /// The `base64Binary` form.
    Base64Binary(super::primitives::Base64Binary),
    /// The `boolean` form.
    Boolean(super::primitives::Boolean),
    /// The `canonical` form.
    Canonical(super::primitives::Canonical),
    /// 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 `integer64` form.
    Integer64(super::primitives::Integer64),
    /// 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 `url` form.
    Url(super::primitives::Url),
    /// The `uuid` form.
    Uuid(super::primitives::Uuid),
    /// 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 `CodeableReference` form.
    CodeableReference(Box<super::codeable_reference::CodeableReference>),
    /// 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 `RatioRange` form.
    RatioRange(Box<super::ratio_range::RatioRange>),
    /// 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 `ContactDetail` form.
    ContactDetail(Box<super::contact_detail::ContactDetail>),
    /// The `DataRequirement` form.
    DataRequirement(Box<super::data_requirement::DataRequirement>),
    /// The `Expression` form.
    Expression(Box<super::expression::Expression>),
    /// The `ParameterDefinition` form.
    ParameterDefinition(Box<super::parameter_definition::ParameterDefinition>),
    /// The `RelatedArtifact` form.
    RelatedArtifact(Box<super::related_artifact::RelatedArtifact>),
    /// The `TriggerDefinition` form.
    TriggerDefinition(Box<super::trigger_definition::TriggerDefinition>),
    /// The `UsageContext` form.
    UsageContext(Box<super::usage_context::UsageContext>),
    /// The `Availability` form.
    Availability(Box<super::availability::Availability>),
    /// The `ExtendedContactDetail` form.
    ExtendedContactDetail(Box<super::extended_contact_detail::ExtendedContactDetail>),
    /// The `VirtualServiceDetail` form.
    VirtualServiceDetail(Box<super::virtual_service_detail::VirtualServiceDetail>),
    /// The `Dosage` form.
    Dosage(Box<super::dosage::Dosage>),
    /// The `Meta` form.
    Meta(Box<super::meta::Meta>),
}

impl ElementDefinitionPattern {
    /// 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::Canonical(inner) => Ok((
                "Canonical",
                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::Integer64(inner) => Ok((
                "Integer64",
                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::Url(inner) => Ok((
                "Url",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Uuid(inner) => Ok((
                "Uuid",
                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::CodeableReference(inner) => Ok((
                "CodeableReference",
                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::RatioRange(inner) => Ok((
                "RatioRange",
                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::ContactDetail(inner) => Ok((
                "ContactDetail",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::DataRequirement(inner) => Ok((
                "DataRequirement",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Expression(inner) => Ok((
                "Expression",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::ParameterDefinition(inner) => Ok((
                "ParameterDefinition",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::RelatedArtifact(inner) => Ok((
                "RelatedArtifact",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::TriggerDefinition(inner) => Ok((
                "TriggerDefinition",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::UsageContext(inner) => Ok((
                "UsageContext",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Availability(inner) => Ok((
                "Availability",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::ExtendedContactDetail(inner) => Ok((
                "ExtendedContactDetail",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::VirtualServiceDetail(inner) => Ok((
                "VirtualServiceDetail",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
            Self::Dosage(inner) => Ok((
                "Dosage",
                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)?,
            )),
            "Canonical" => Ok(Self::Canonical(
                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)?,
            )),
            "Integer64" => Ok(Self::Integer64(
                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,
            )?)),
            "Url" => Ok(Self::Url(super::super::codec::Primitive::from_json_parts(
                value, element, path,
            )?)),
            "Uuid" => Ok(Self::Uuid(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)))
            }
            "CodeableReference" => {
                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::CodeableReference(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)))
            }
            "RatioRange" => {
                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::RatioRange(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)))
            }
            "ContactDetail" => {
                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::ContactDetail(Box::new(inner)))
            }
            "DataRequirement" => {
                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::DataRequirement(Box::new(inner)))
            }
            "Expression" => {
                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::Expression(Box::new(inner)))
            }
            "ParameterDefinition" => {
                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::ParameterDefinition(Box::new(inner)))
            }
            "RelatedArtifact" => {
                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::RelatedArtifact(Box::new(inner)))
            }
            "TriggerDefinition" => {
                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::TriggerDefinition(Box::new(inner)))
            }
            "UsageContext" => {
                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::UsageContext(Box::new(inner)))
            }
            "Availability" => {
                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::Availability(Box::new(inner)))
            }
            "ExtendedContactDetail" => {
                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::ExtendedContactDetail(Box::new(inner)))
            }
            "VirtualServiceDetail" => {
                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::VirtualServiceDetail(Box::new(inner)))
            }
            "Dosage" => {
                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::Dosage(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)),
        }
    }
}

/// This element is sliced - slices follow
///
/// Indicates that the element is sliced into a set of alternative definitions
/// (i.e. in a structure definition, there are multiple different constraints on
/// a single element in the base resource). Slicing can be used in any resource
/// that has cardinality ..\* on the base resource, or any resource with a
/// choice of types. The set of slices is any elements that come after this in
/// the element sequence that have the same path, until a shorter path occurs
/// (the shorter path terminates the set).
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct ElementDefinitionSlicing {
    /// Unique id for inter-element referencing
    ///
    /// 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. To make the use of extensions safe and
    /// managable, there is a strict set of governance applied to the definition and
    /// use of extensions. Though any implementer can 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>,
    /// Element values that are used to distinguish the slices
    ///
    /// Designates which child elements are used to discriminate between the slices
    /// when processing an instance. If one or more discriminators are provided, the
    /// values of the child elements in the instance data SHALL completely
    /// distinguish which slice the element in the resource matches based on the
    /// allowed values for those elements in each of the slices.
    pub discriminator: Vec<ElementDefinitionSlicingDiscriminator>,
    /// Text description of how slicing works (or not)
    ///
    /// A human-readable text description of how the slicing works. If there is no
    /// discriminator, this is required to be present to provide whatever
    /// information is possible about how the slices can be differentiated.
    pub description: Option<super::primitives::String>,
    /// If elements must be in same order as slices
    ///
    /// If the matching elements have to occur in the same order as defined in the
    /// profile.
    pub ordered: Option<super::primitives::Boolean>,
    /// closed | open | openAtEnd
    ///
    /// Whether additional slices are allowed or not. When the slices are ordered,
    /// profile authors can also say that additional slices are only allowed at the
    /// end.
    pub rules: super::primitives::Code,
}

impl super::super::codec::Json for ElementDefinitionSlicing {
    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.discriminator.is_empty() {
            let mut items = Vec::with_capacity(self.discriminator.len());
            for item in &self.discriminator {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("discriminator"),
                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 let Some(item) = &self.ordered {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("ordered"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_ordered"), e);
            }
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.rules)? {
            object.insert(std::string::String::from("rules"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.rules)? {
            object.insert(std::string::String::from("_rules"), 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_discriminator: 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_ordered: Option<&super::super::codec::Value> = None;
        let mut raw_ordered_element: Option<&super::super::codec::Value> = None;
        let mut raw_rules: Option<&super::super::codec::Value> = None;
        let mut raw_rules_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);
                }
                "discriminator" => {
                    raw_discriminator = Some(value);
                }
                "description" => {
                    raw_description = Some(value);
                }
                "_description" => {
                    raw_description_element = Some(value);
                }
                "ordered" => {
                    raw_ordered = Some(value);
                }
                "_ordered" => {
                    raw_ordered_element = Some(value);
                }
                "rules" => {
                    raw_rules = Some(value);
                }
                "_rules" => {
                    raw_rules_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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        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_discriminator = Vec::new();
        if let Some(raw) = raw_discriminator {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_discriminator.push(path.with_index("discriminator", 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 field_ordered = match (raw_ordered, raw_ordered_element) {
            (None, None) => None,
            (value, element) => Some(path.with("ordered", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_rules = path.with("rules", |path| {
            super::super::codec::Primitive::from_json_parts(raw_rules, raw_rules_element, path)
        })?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            discriminator: field_discriminator,
            description: field_description,
            ordered: field_ordered,
            rules: field_rules,
        })
    }
}

impl serde::Serialize for ElementDefinitionSlicing {
    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.description {
            super::super::codec::element_entry(&mut map, "_description", item)?;
        }
        if let Some(item) = &self.ordered {
            super::super::codec::element_entry(&mut map, "_ordered", item)?;
        }
        super::super::codec::element_entry(&mut map, "_rules", &self.rules)?;
        if let Some(item) = &self.description {
            super::super::codec::value_entry(&mut map, "description", item)?;
        }
        if !self.discriminator.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "discriminator",
                &self.discriminator,
            )?;
        }
        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.ordered {
            super::super::codec::value_entry(&mut map, "ordered", item)?;
        }
        super::super::codec::value_entry(&mut map, "rules", &self.rules)?;
        serde::ser::SerializeMap::end(map)
    }
}

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

/// Element values that are used to distinguish the slices
///
/// Designates which child elements are used to discriminate between the slices
/// when processing an instance. If one or more discriminators are provided, the
/// values of the child elements in the instance data SHALL completely
/// distinguish which slice the element in the resource matches based on the
/// allowed values for those elements in each of the slices.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct ElementDefinitionSlicingDiscriminator {
    /// Unique id for inter-element referencing
    ///
    /// 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. To make the use of extensions safe and
    /// managable, there is a strict set of governance applied to the definition and
    /// use of extensions. Though any implementer can 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>,
    /// value | exists | type | profile | position
    ///
    /// How the element value is interpreted when discrimination is evaluated.
    pub r#type: super::primitives::Code,
    /// Path to element value
    ///
    /// A FHIRPath expression, using \[the simple subset of
    /// FHIRPath\](fhirpath.html\#simple), that is used to identify the element on
    /// which discrimination is based.
    pub path: super::primitives::String,
}

impl super::super::codec::Json for ElementDefinitionSlicingDiscriminator {
    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 let Some(v) = super::super::codec::Primitive::value_json(&self.r#type)? {
            object.insert(std::string::String::from("type"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.r#type)? {
            object.insert(std::string::String::from("_type"), e);
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.path)? {
            object.insert(std::string::String::from("path"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.path)? {
            object.insert(std::string::String::from("_path"), 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_type: Option<&super::super::codec::Value> = None;
        let mut raw_type_element: Option<&super::super::codec::Value> = None;
        let mut raw_path: Option<&super::super::codec::Value> = None;
        let mut raw_path_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);
                }
                "type" => {
                    raw_type = Some(value);
                }
                "_type" => {
                    raw_type_element = Some(value);
                }
                "path" => {
                    raw_path = Some(value);
                }
                "_path" => {
                    raw_path_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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        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 field_type = path.with("type", |path| {
            super::super::codec::Primitive::from_json_parts(raw_type, raw_type_element, path)
        })?;
        let field_path = path.with("path", |path| {
            super::super::codec::Primitive::from_json_parts(raw_path, raw_path_element, path)
        })?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            r#type: field_type,
            path: field_path,
        })
    }
}

impl serde::Serialize for ElementDefinitionSlicingDiscriminator {
    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, "_path", &self.path)?;
        super::super::codec::element_entry(&mut map, "_type", &self.r#type)?;
        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, "path", &self.path)?;
        super::super::codec::value_entry(&mut map, "type", &self.r#type)?;
        serde::ser::SerializeMap::end(map)
    }
}

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

/// Data type and Profile for this element
///
/// The data type or resource that the value of this element is permitted to be.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct ElementDefinitionType {
    /// Unique id for inter-element referencing
    ///
    /// 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. To make the use of extensions safe and
    /// managable, there is a strict set of governance applied to the definition and
    /// use of extensions. Though any implementer can 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>,
    /// Data type or Resource (reference to definition)
    ///
    /// URL of Data type or Resource that is a(or the) type used for this element.
    /// References are URLs that are relative to
    /// <http://hl7.org/fhir/StructureDefinition> e.g. "string" is a reference to
    /// <http://hl7.org/fhir/StructureDefinition/string>. Absolute URLs are only
    /// allowed in logical models.
    pub code: super::primitives::Uri,
    /// Profiles (StructureDefinition or IG) - one must apply
    ///
    /// Identifies a profile structure or implementation Guide that applies to the
    /// datatype this element refers to. If any profiles are specified, then the
    /// content must conform to at least one of them. The URL can be a local
    /// reference - to a contained StructureDefinition, or a reference to another
    /// StructureDefinition or Implementation Guide by a canonical URL. When an
    /// implementation guide is specified, the type SHALL conform to at least one
    /// profile defined in the implementation guide.
    pub profile: Vec<super::primitives::Canonical>,
    /// Profile (StructureDefinition or IG) on the Reference/canonical target - one
    /// must apply
    ///
    /// Used when the type is "Reference" or "canonical", and identifies a profile
    /// structure or implementation Guide that applies to the target of the
    /// reference this element refers to. If any profiles are specified, then the
    /// content must conform to at least one of them. The URL can be a local
    /// reference - to a contained StructureDefinition, or a reference to another
    /// StructureDefinition or Implementation Guide by a canonical URL. When an
    /// implementation guide is specified, the target resource SHALL conform to at
    /// least one profile defined in the implementation guide.
    pub target_profile: Vec<super::primitives::Canonical>,
    /// contained | referenced | bundled - how aggregated
    ///
    /// If the type is a reference to another resource, how the resource is or can
    /// be aggregated - is it a contained resource, or a reference, and if the
    /// context is a bundle, is it included in the bundle.
    pub aggregation: Vec<super::primitives::Code>,
    /// either | independent | specific
    ///
    /// Whether this reference needs to be version specific or version independent,
    /// or whether either can be used.
    pub versioning: Option<super::primitives::Code>,
}

impl super::super::codec::Json for ElementDefinitionType {
    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 let Some(v) = super::super::codec::Primitive::value_json(&self.code)? {
            object.insert(std::string::String::from("code"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.code)? {
            object.insert(std::string::String::from("_code"), e);
        }
        if !self.profile.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.profile)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("profile"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_profile"), elements);
            }
        }
        if !self.target_profile.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.target_profile)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("targetProfile"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_targetProfile"), elements);
            }
        }
        if !self.aggregation.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.aggregation)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("aggregation"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_aggregation"), elements);
            }
        }
        if let Some(item) = &self.versioning {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("versioning"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_versioning"), 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_code: Option<&super::super::codec::Value> = None;
        let mut raw_code_element: Option<&super::super::codec::Value> = None;
        let mut raw_profile: Option<&super::super::codec::Value> = None;
        let mut raw_profile_element: Option<&super::super::codec::Value> = None;
        let mut raw_target_profile: Option<&super::super::codec::Value> = None;
        let mut raw_target_profile_element: Option<&super::super::codec::Value> = None;
        let mut raw_aggregation: Option<&super::super::codec::Value> = None;
        let mut raw_aggregation_element: Option<&super::super::codec::Value> = None;
        let mut raw_versioning: Option<&super::super::codec::Value> = None;
        let mut raw_versioning_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);
                }
                "code" => {
                    raw_code = Some(value);
                }
                "_code" => {
                    raw_code_element = Some(value);
                }
                "profile" => {
                    raw_profile = Some(value);
                }
                "_profile" => {
                    raw_profile_element = Some(value);
                }
                "targetProfile" => {
                    raw_target_profile = Some(value);
                }
                "_targetProfile" => {
                    raw_target_profile_element = Some(value);
                }
                "aggregation" => {
                    raw_aggregation = Some(value);
                }
                "_aggregation" => {
                    raw_aggregation_element = Some(value);
                }
                "versioning" => {
                    raw_versioning = Some(value);
                }
                "_versioning" => {
                    raw_versioning_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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        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 field_code = path.with("code", |path| {
            super::super::codec::Primitive::from_json_parts(raw_code, raw_code_element, path)
        })?;
        let mut field_profile = Vec::new();
        for (index, (value, element)) in
            super::super::codec::pair_arrays(raw_profile, raw_profile_element, path)?
                .into_iter()
                .enumerate()
        {
            field_profile.push(path.with_index("profile", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let mut field_target_profile = Vec::new();
        for (index, (value, element)) in
            super::super::codec::pair_arrays(raw_target_profile, raw_target_profile_element, path)?
                .into_iter()
                .enumerate()
        {
            field_target_profile.push(path.with_index("targetProfile", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let mut field_aggregation = Vec::new();
        for (index, (value, element)) in
            super::super::codec::pair_arrays(raw_aggregation, raw_aggregation_element, path)?
                .into_iter()
                .enumerate()
        {
            field_aggregation.push(path.with_index("aggregation", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let field_versioning = match (raw_versioning, raw_versioning_element) {
            (None, None) => None,
            (value, element) => Some(path.with("versioning", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            code: field_code,
            profile: field_profile,
            target_profile: field_target_profile,
            aggregation: field_aggregation,
            versioning: field_versioning,
        })
    }
}

impl serde::Serialize for ElementDefinitionType {
    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_list_entry(&mut map, "_aggregation", &self.aggregation)?;
        super::super::codec::element_entry(&mut map, "_code", &self.code)?;
        super::super::codec::element_list_entry(&mut map, "_profile", &self.profile)?;
        super::super::codec::element_list_entry(&mut map, "_targetProfile", &self.target_profile)?;
        if let Some(item) = &self.versioning {
            super::super::codec::element_entry(&mut map, "_versioning", item)?;
        }
        super::super::codec::value_list_entry(&mut map, "aggregation", &self.aggregation)?;
        super::super::codec::value_entry(&mut map, "code", &self.code)?;
        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, "profile", &self.profile)?;
        super::super::codec::value_list_entry(&mut map, "targetProfile", &self.target_profile)?;
        if let Some(item) = &self.versioning {
            super::super::codec::value_entry(&mut map, "versioning", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

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