fhir_types/r5/

parameters.rs

// @generated by fhir-codegen from hl7.fhir.r5.core 5.0.0. DO NOT EDIT.
// Change the emitter (tools/fhir-codegen) and regenerate.
// SPDX-FileCopyrightText: Cadasto B.V.
// SPDX-License-Identifier: Apache-2.0
//! Operation Request or Response

/// Operation Request or Response
///
/// This resource is used to pass information into and back from an operation
/// (whether invoked directly from REST or within a messaging environment). It
/// is not persisted or allowed to be referenced by other resources.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Parameters {
    /// Logical id of this artifact
    ///
    /// The logical id of the resource, as used in the URL for the resource. Once
    /// assigned, this value never changes.
    pub id: Option<std::string::String>,
    /// Metadata about the resource
    ///
    /// The metadata about the resource. This is content that is maintained by the
    /// infrastructure. Changes to the content might not always be associated with
    /// version changes to the resource.
    pub meta: Option<super::meta::Meta>,
    /// A set of rules under which this content was created
    ///
    /// A reference to a set of rules that were followed when the resource was
    /// constructed, and which must be understood when processing the content.
    /// Often, this is a reference to an implementation guide that defines the
    /// special rules along with other profiles etc.
    pub implicit_rules: Option<super::primitives::Uri>,
    /// Language of the resource content
    ///
    /// The base language in which the resource is written.
    pub language: Option<super::primitives::Code>,
    /// Operation Parameter
    ///
    /// A parameter passed to or received from the operation.
    pub parameter: Vec<ParametersParameter>,
}

impl super::super::codec::Json for Parameters {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        object.insert(
            std::string::String::from("resourceType"),
            super::super::codec::Value::String(std::string::String::from("Parameters")),
        );
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if let Some(item) = &self.meta {
            object.insert(
                std::string::String::from("meta"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.implicit_rules {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("implicitRules"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_implicitRules"), e);
            }
        }
        if let Some(item) = &self.language {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("language"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_language"), e);
            }
        }
        if !self.parameter.is_empty() {
            let mut items = Vec::with_capacity(self.parameter.len());
            for item in &self.parameter {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("parameter"),
                super::super::codec::Value::Array(items),
            );
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_meta: Option<&super::super::codec::Value> = None;
        let mut raw_implicit_rules: Option<&super::super::codec::Value> = None;
        let mut raw_implicit_rules_element: Option<&super::super::codec::Value> = None;
        let mut raw_language: Option<&super::super::codec::Value> = None;
        let mut raw_language_element: Option<&super::super::codec::Value> = None;
        let mut raw_parameter: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "resourceType" => {
                    if value.as_str() != Some("Parameters") {
                        return Err(path.error(super::super::codec::DecodeErrorKind::ResourceType));
                    }
                }
                "id" => {
                    raw_id = Some(value);
                }
                "meta" => {
                    raw_meta = Some(value);
                }
                "implicitRules" => {
                    raw_implicit_rules = Some(value);
                }
                "_implicitRules" => {
                    raw_implicit_rules_element = Some(value);
                }
                "language" => {
                    raw_language = Some(value);
                }
                "_language" => {
                    raw_language_element = Some(value);
                }
                "parameter" => {
                    raw_parameter = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::primitives::checked_id(
                        super::super::codec::expect_string(value, path)?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_meta = raw_meta
            .map(|value| {
                path.with("meta", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_implicit_rules = match (raw_implicit_rules, raw_implicit_rules_element) {
            (None, None) => None,
            (value, element) => Some(path.with("implicitRules", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_language = match (raw_language, raw_language_element) {
            (None, None) => None,
            (value, element) => Some(path.with("language", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_parameter = Vec::new();
        if let Some(raw) = raw_parameter {
            for (index, value) in path
                .with("parameter", |path| {
                    super::super::codec::expect_array(raw, path)
                })?
                .iter()
                .enumerate()
            {
                field_parameter.push(path.with_index("parameter", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        Ok(Self {
            id: field_id,
            meta: field_meta,
            implicit_rules: field_implicit_rules,
            language: field_language,
            parameter: field_parameter,
        })
    }
}

impl serde::Serialize for Parameters {
    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.implicit_rules {
            super::super::codec::element_entry(&mut map, "_implicitRules", item)?;
        }
        if let Some(item) = &self.language {
            super::super::codec::element_entry(&mut map, "_language", item)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if let Some(item) = &self.implicit_rules {
            super::super::codec::value_entry(&mut map, "implicitRules", item)?;
        }
        if let Some(item) = &self.language {
            super::super::codec::value_entry(&mut map, "language", item)?;
        }
        if let Some(item) = &self.meta {
            serde::ser::SerializeMap::serialize_entry(&mut map, "meta", item)?;
        }
        if !self.parameter.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "parameter", &self.parameter)?;
        }
        serde::ser::SerializeMap::serialize_entry(&mut map, "resourceType", "Parameters")?;
        serde::ser::SerializeMap::end(map)
    }
}

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

/// Operation Parameter
///
/// A parameter passed to or received from the operation.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct ParametersParameter {
    /// 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>,
    /// Name from the definition
    ///
    /// The name of the parameter (reference to the operation definition).
    pub name: super::primitives::String,
    /// If parameter is a data type
    ///
    /// Conveys the content if the parameter is a data type.
    pub value: Option<ParametersParameterValue>,
    /// If parameter is a whole resource
    ///
    /// Conveys the content if the parameter is a whole resource.
    pub resource: Option<super::resource::Resource>,
    /// Named part of a multi-part parameter
    ///
    /// A named part of a multi-part parameter.
    pub part: Vec<ParametersParameter>,
}

impl super::super::codec::Json for ParametersParameter {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.name)? {
            object.insert(std::string::String::from("name"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.name)? {
            object.insert(std::string::String::from("_name"), e);
        }
        if let Some(item) = &self.value {
            let (suffix, value, element) = item.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);
            }
        }
        if let Some(item) = &self.resource {
            object.insert(
                std::string::String::from("resource"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if !self.part.is_empty() {
            let mut items = Vec::with_capacity(self.part.len());
            for item in &self.part {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("part"),
                super::super::codec::Value::Array(items),
            );
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_name: Option<&super::super::codec::Value> = None;
        let mut raw_name_element: Option<&super::super::codec::Value> = None;
        let mut raw_value = super::super::codec::ChoiceSlot::default();
        let mut raw_resource: Option<&super::super::codec::Value> = None;
        let mut raw_part: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "name" => {
                    raw_name = Some(value);
                }
                "_name" => {
                    raw_name_element = Some(value);
                }
                "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)?;
                }
                "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)?;
                }
                "resource" => {
                    raw_resource = Some(value);
                }
                "part" => {
                    raw_part = 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 path
                .with("extension", |path| {
                    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 path
                .with("modifierExtension", |path| {
                    super::super::codec::expect_array(raw, path)
                })?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_name = path.with("name", |path| {
            super::super::codec::Primitive::from_json_parts(raw_name, raw_name_element, path)
        })?;
        let field_value = match raw_value.suffix {
            None => None,
            Some(suffix) => Some(path.with("value", |path| {
                ParametersParameterValue::from_json_parts(
                    suffix,
                    raw_value.value,
                    raw_value.element,
                    path,
                )
            })?),
        };
        let field_resource = raw_resource
            .map(|value| {
                path.with("resource", |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_part = Vec::new();
        if let Some(raw) = raw_part {
            for (index, value) in path
                .with("part", |path| super::super::codec::expect_array(raw, path))?
                .iter()
                .enumerate()
            {
                field_part.push(path.with_index("part", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            name: field_name,
            value: field_value,
            resource: field_resource,
            part: field_part,
        })
    }
}

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

impl<'de> serde::Deserialize<'de> for ParametersParameter {
    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("ParametersParameter");
        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 \`ParametersParameter\`.
///
/// Conveys the content if the parameter is a data type.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ParametersParameterValue {
    /// 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 `Dosage` form.
    Dosage(Box<super::dosage::Dosage>),
    /// The `Meta` form.
    Meta(Box<super::meta::Meta>),
}

impl ParametersParameterValue {
    /// 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::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)))
            }
            "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)),
        }
    }
}