fhir-types 0.1.115

// @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
//! The FHIR primitive types (<https://hl7.org/fhir/R5/datatypes.html#primitive>).

/// Primitive Type base64Binary
///
/// A stream of bytes
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Base64Binary {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for base64Binary
    ///
    /// The actual value
    pub value: Option<std::string::String>,
}
impl From<std::string::String> for Base64Binary {
    fn from(value: std::string::String) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}
impl From<&str> for Base64Binary {
    fn from(value: &str) -> Self {
        Self::from(std::string::String::from(value))
    }
}

/// The lexical form of the FHIR primitive `base64Binary`, anchored to the whole value.
///
/// The `regex` extension of `base64Binary.value` states it (<https://hl7.org/fhir/R5/datatypes.html#primitive>),
/// and the form is an XML Schema pattern, where `\s` is the space, the tab,
/// the carriage return and the line feed alone (<https://www.w3.org/TR/xmlschema-2/#regexs>).
#[expect(
    clippy::expect_used,
    reason = "the emitter compiles every lexical form it writes, so the pattern holds"
)]
static BASE64_BINARY_LEXICAL_FORM: std::sync::LazyLock<regex::bytes::Regex> =
    std::sync::LazyLock::new(|| {
        regex::bytes::RegexBuilder::new(
            r"^(?:(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?)$",
        )
        .unicode(false)
        .build()
        .expect("the lexical form of `base64Binary` should compile")
    });

/// Hands back `text` when it keeps the lexical form of `base64Binary`.
///
/// # Errors
///
/// Returns [`super::super::codec::DecodeErrorKind::BadValue`] at `path` for a value outside the form.
pub(crate) fn checked_base64_binary(
    text: std::string::String,
    path: &super::super::codec::Path,
) -> Result<std::string::String, super::super::codec::DecodeError> {
    if BASE64_BINARY_LEXICAL_FORM.is_match(text.as_bytes()) {
        Ok(text)
    } else {
        Err(path.error(super::super::codec::DecodeErrorKind::BadValue))
    }
}

impl super::super::codec::Primitive for Base64Binary {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::String(v.clone())))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_str(serializer, v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(checked_base64_binary(
                    super::super::codec::expect_string(value, path)?,
                    path,
                )?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type boolean
///
/// Value of "true" or "false"
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Boolean {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for boolean
    ///
    /// The actual value
    pub value: Option<bool>,
}
impl From<bool> for Boolean {
    fn from(value: bool) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}

impl super::super::codec::Primitive for Boolean {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::Bool(*v)))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_bool(serializer, *v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(super::super::codec::expect_bool(value, path)?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type canonical
///
/// A URI that is a reference to a canonical URL on a FHIR resource
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Canonical {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for canonical
    pub value: Option<std::string::String>,
}
impl From<std::string::String> for Canonical {
    fn from(value: std::string::String) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}
impl From<&str> for Canonical {
    fn from(value: &str) -> Self {
        Self::from(std::string::String::from(value))
    }
}

/// The lexical form of the FHIR primitive `canonical`, anchored to the whole value.
///
/// The `regex` extension of `canonical.value` states it (<https://hl7.org/fhir/R5/datatypes.html#primitive>),
/// and the form is an XML Schema pattern, where `\s` is the space, the tab,
/// the carriage return and the line feed alone (<https://www.w3.org/TR/xmlschema-2/#regexs>).
#[expect(
    clippy::expect_used,
    reason = "the emitter compiles every lexical form it writes, so the pattern holds"
)]
static CANONICAL_LEXICAL_FORM: std::sync::LazyLock<regex::bytes::Regex> =
    std::sync::LazyLock::new(|| {
        regex::bytes::RegexBuilder::new(r"^(?:\S*)$")
            .unicode(false)
            .build()
            .expect("the lexical form of `canonical` should compile")
    });

/// Hands back `text` when it keeps the lexical form of `canonical`.
///
/// # Errors
///
/// Returns [`super::super::codec::DecodeErrorKind::BadValue`] at `path` for a value outside the form.
pub(crate) fn checked_canonical(
    text: std::string::String,
    path: &super::super::codec::Path,
) -> Result<std::string::String, super::super::codec::DecodeError> {
    if CANONICAL_LEXICAL_FORM.is_match(text.as_bytes()) {
        Ok(text)
    } else {
        Err(path.error(super::super::codec::DecodeErrorKind::BadValue))
    }
}

impl super::super::codec::Primitive for Canonical {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::String(v.clone())))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_str(serializer, v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(checked_canonical(
                    super::super::codec::expect_string(value, path)?,
                    path,
                )?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type code
///
/// A string which has at least one character and no leading or trailing
/// whitespace and where there is no whitespace other than single spaces in the
/// contents
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Code {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for code
    pub value: Option<std::string::String>,
}
impl From<std::string::String> for Code {
    fn from(value: std::string::String) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}
impl From<&str> for Code {
    fn from(value: &str) -> Self {
        Self::from(std::string::String::from(value))
    }
}

/// The lexical form of the FHIR primitive `code`, anchored to the whole value.
///
/// The `regex` extension of `code.value` states it (<https://hl7.org/fhir/R5/datatypes.html#primitive>),
/// and the form is an XML Schema pattern, where `\s` is the space, the tab,
/// the carriage return and the line feed alone (<https://www.w3.org/TR/xmlschema-2/#regexs>).
#[expect(
    clippy::expect_used,
    reason = "the emitter compiles every lexical form it writes, so the pattern holds"
)]
static CODE_LEXICAL_FORM: std::sync::LazyLock<regex::bytes::Regex> =
    std::sync::LazyLock::new(|| {
        regex::bytes::RegexBuilder::new(r"^(?:[^\s]+( [^\s]+)*)$")
            .unicode(false)
            .build()
            .expect("the lexical form of `code` should compile")
    });

/// Hands back `text` when it keeps the lexical form of `code`.
///
/// # Errors
///
/// Returns [`super::super::codec::DecodeErrorKind::BadValue`] at `path` for a value outside the form.
pub(crate) fn checked_code(
    text: std::string::String,
    path: &super::super::codec::Path,
) -> Result<std::string::String, super::super::codec::DecodeError> {
    if CODE_LEXICAL_FORM.is_match(text.as_bytes()) {
        Ok(text)
    } else {
        Err(path.error(super::super::codec::DecodeErrorKind::BadValue))
    }
}

impl super::super::codec::Primitive for Code {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::String(v.clone())))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_str(serializer, v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(checked_code(
                    super::super::codec::expect_string(value, path)?,
                    path,
                )?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type date
///
/// A date or partial date (e.g. just year or year + month). There is no UTC
/// offset. The format is a union of the schema types gYear, gYearMonth and
/// date. Dates SHALL be valid dates.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Date {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for date
    ///
    /// The actual value
    pub value: Option<std::string::String>,
}
impl From<std::string::String> for Date {
    fn from(value: std::string::String) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}
impl From<&str> for Date {
    fn from(value: &str) -> Self {
        Self::from(std::string::String::from(value))
    }
}

/// The lexical form of the FHIR primitive `date`, anchored to the whole value.
///
/// The `regex` extension of `date.value` states it (<https://hl7.org/fhir/R5/datatypes.html#primitive>),
/// and the form is an XML Schema pattern, where `\s` is the space, the tab,
/// the carriage return and the line feed alone (<https://www.w3.org/TR/xmlschema-2/#regexs>).
#[expect(
    clippy::expect_used,
    reason = "the emitter compiles every lexical form it writes, so the pattern holds"
)]
static DATE_LEXICAL_FORM: std::sync::LazyLock<regex::bytes::Regex> = std::sync::LazyLock::new(
    || {
        regex::bytes::RegexBuilder::new(r"^(?:([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1]))?)?)$")
        .unicode(false)
        .build()
        .expect("the lexical form of `date` should compile")
    },
);

/// Hands back `text` when it keeps the lexical form of `date`.
///
/// # Errors
///
/// Returns [`super::super::codec::DecodeErrorKind::BadValue`] at `path` for a value outside the form.
pub(crate) fn checked_date(
    text: std::string::String,
    path: &super::super::codec::Path,
) -> Result<std::string::String, super::super::codec::DecodeError> {
    if DATE_LEXICAL_FORM.is_match(text.as_bytes()) {
        Ok(text)
    } else {
        Err(path.error(super::super::codec::DecodeErrorKind::BadValue))
    }
}

impl super::super::codec::Primitive for Date {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::String(v.clone())))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_str(serializer, v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(checked_date(
                    super::super::codec::expect_string(value, path)?,
                    path,
                )?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type dateTime
///
/// A date, date-time or partial date (e.g. just year or year + month). If hours
/// and minutes are specified, a UTC offset SHALL be populated. The format is a
/// union of the schema types gYear, gYearMonth, date and dateTime. Seconds must
/// be provided due to schema type constraints but may be zero-filled and may be
/// ignored. Dates SHALL be valid dates.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct DateTime {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for dateTime
    ///
    /// The actual value
    pub value: Option<std::string::String>,
}
impl From<std::string::String> for DateTime {
    fn from(value: std::string::String) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}
impl From<&str> for DateTime {
    fn from(value: &str) -> Self {
        Self::from(std::string::String::from(value))
    }
}

/// The lexical form of the FHIR primitive `dateTime`, anchored to the whole value.
///
/// The `regex` extension of `dateTime.value` states it (<https://hl7.org/fhir/R5/datatypes.html#primitive>),
/// and the form is an XML Schema pattern, where `\s` is the space, the tab,
/// the carriage return and the line feed alone (<https://www.w3.org/TR/xmlschema-2/#regexs>).
#[expect(
    clippy::expect_used,
    reason = "the emitter compiles every lexical form it writes, so the pattern holds"
)]
static DATE_TIME_LEXICAL_FORM: std::sync::LazyLock<regex::bytes::Regex> = std::sync::LazyLock::new(
    || {
        regex::bytes::RegexBuilder::new(r"^(?:([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]{1,9})?)?)?(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)?)?)?)$")
        .unicode(false)
        .build()
        .expect("the lexical form of `dateTime` should compile")
    },
);

/// Hands back `text` when it keeps the lexical form of `dateTime`.
///
/// # Errors
///
/// Returns [`super::super::codec::DecodeErrorKind::BadValue`] at `path` for a value outside the form.
pub(crate) fn checked_date_time(
    text: std::string::String,
    path: &super::super::codec::Path,
) -> Result<std::string::String, super::super::codec::DecodeError> {
    if DATE_TIME_LEXICAL_FORM.is_match(text.as_bytes()) {
        Ok(text)
    } else {
        Err(path.error(super::super::codec::DecodeErrorKind::BadValue))
    }
}

impl super::super::codec::Primitive for DateTime {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::String(v.clone())))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_str(serializer, v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(checked_date_time(
                    super::super::codec::expect_string(value, path)?,
                    path,
                )?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type decimal
///
/// A rational number with implicit precision
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Decimal {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for decimal
    ///
    /// The actual value
    pub value: Option<std::string::String>,
}
impl From<std::string::String> for Decimal {
    fn from(value: std::string::String) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}
impl From<&str> for Decimal {
    fn from(value: &str) -> Self {
        Self::from(std::string::String::from(value))
    }
}

impl super::super::codec::Primitive for Decimal {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        self.value
            .as_ref()
            .map(|text| {
                text.parse::<super::super::codec::Number>()
                    .map(super::super::codec::Value::Number)
                    .map_err(|_| super::super::codec::EncodeError::BadDecimal {
                        text: text.clone(),
                    })
            })
            .transpose()
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(text) => serde::Serialize::serialize(
                &text.parse::<super::super::codec::Number>().map_err(|_| {
                    <S::Error as serde::ser::Error>::custom(
                        super::super::codec::EncodeError::BadDecimal { text: text.clone() },
                    )
                })?,
                serializer,
            ),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(super::super::codec::expect_decimal(value, path)?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type id
///
/// Any combination of letters, numerals, "-" and ".", with a length limit of 64
/// characters. (This might be an integer, an unprefixed OID, UUID or any other
/// identifier pattern that meets these constraints.) Ids are case-insensitive.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Id {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for id
    pub value: Option<std::string::String>,
}
impl From<std::string::String> for Id {
    fn from(value: std::string::String) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}
impl From<&str> for Id {
    fn from(value: &str) -> Self {
        Self::from(std::string::String::from(value))
    }
}

/// The lexical form of the FHIR primitive `id`, anchored to the whole value.
///
/// The `regex` extension of `id.value` states it (<https://hl7.org/fhir/R5/datatypes.html#primitive>),
/// and the form is an XML Schema pattern, where `\s` is the space, the tab,
/// the carriage return and the line feed alone (<https://www.w3.org/TR/xmlschema-2/#regexs>).
#[expect(
    clippy::expect_used,
    reason = "the emitter compiles every lexical form it writes, so the pattern holds"
)]
static ID_LEXICAL_FORM: std::sync::LazyLock<regex::bytes::Regex> = std::sync::LazyLock::new(|| {
    regex::bytes::RegexBuilder::new(r"^(?:[A-Za-z0-9\-\.]{1,64})$")
        .unicode(false)
        .build()
        .expect("the lexical form of `id` should compile")
});

/// Hands back `text` when it keeps the lexical form of `id`.
///
/// # Errors
///
/// Returns [`super::super::codec::DecodeErrorKind::BadValue`] at `path` for a value outside the form.
pub(crate) fn checked_id(
    text: std::string::String,
    path: &super::super::codec::Path,
) -> Result<std::string::String, super::super::codec::DecodeError> {
    if ID_LEXICAL_FORM.is_match(text.as_bytes()) {
        Ok(text)
    } else {
        Err(path.error(super::super::codec::DecodeErrorKind::BadValue))
    }
}

impl super::super::codec::Primitive for Id {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::String(v.clone())))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_str(serializer, v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(checked_id(
                    super::super::codec::expect_string(value, path)?,
                    path,
                )?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type instant
///
/// An instant in time - known at least to the second
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Instant {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for instant
    ///
    /// The actual value
    pub value: Option<std::string::String>,
}
impl From<std::string::String> for Instant {
    fn from(value: std::string::String) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}
impl From<&str> for Instant {
    fn from(value: &str) -> Self {
        Self::from(std::string::String::from(value))
    }
}

/// The lexical form of the FHIR primitive `instant`, anchored to the whole value.
///
/// The `regex` extension of `instant.value` states it (<https://hl7.org/fhir/R5/datatypes.html#primitive>),
/// and the form is an XML Schema pattern, where `\s` is the space, the tab,
/// the carriage return and the line feed alone (<https://www.w3.org/TR/xmlschema-2/#regexs>).
#[expect(
    clippy::expect_used,
    reason = "the emitter compiles every lexical form it writes, so the pattern holds"
)]
static INSTANT_LEXICAL_FORM: std::sync::LazyLock<regex::bytes::Regex> = std::sync::LazyLock::new(
    || {
        regex::bytes::RegexBuilder::new(r"^(?:([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]{1,9})?(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))$")
        .unicode(false)
        .build()
        .expect("the lexical form of `instant` should compile")
    },
);

/// Hands back `text` when it keeps the lexical form of `instant`.
///
/// # Errors
///
/// Returns [`super::super::codec::DecodeErrorKind::BadValue`] at `path` for a value outside the form.
pub(crate) fn checked_instant(
    text: std::string::String,
    path: &super::super::codec::Path,
) -> Result<std::string::String, super::super::codec::DecodeError> {
    if INSTANT_LEXICAL_FORM.is_match(text.as_bytes()) {
        Ok(text)
    } else {
        Err(path.error(super::super::codec::DecodeErrorKind::BadValue))
    }
}

impl super::super::codec::Primitive for Instant {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::String(v.clone())))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_str(serializer, v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(checked_instant(
                    super::super::codec::expect_string(value, path)?,
                    path,
                )?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type integer
///
/// A whole number
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Integer {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for integer
    ///
    /// The actual value
    pub value: Option<i32>,
}
impl From<i32> for Integer {
    fn from(value: i32) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}

impl super::super::codec::Primitive for Integer {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::from(*v)))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_i32(serializer, *v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(super::super::codec::expect_i32(value, path)?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type integer64
///
/// A very large whole number
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Integer64 {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for integer64
    ///
    /// The actual value
    pub value: Option<i64>,
}
impl From<i64> for Integer64 {
    fn from(value: i64) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}

impl super::super::codec::Primitive for Integer64 {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::String(v.to_string())))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_str(serializer, &v.to_string()),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(super::super::codec::expect_i64_string(value, path)?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type markdown
///
/// A string that may contain Github Flavored Markdown syntax for optional
/// processing by a mark down presentation engine
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Markdown {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for markdown
    pub value: Option<std::string::String>,
}
impl From<std::string::String> for Markdown {
    fn from(value: std::string::String) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}
impl From<&str> for Markdown {
    fn from(value: &str) -> Self {
        Self::from(std::string::String::from(value))
    }
}

/// The lexical form of the FHIR primitive `markdown`, anchored to the whole value.
///
/// The `regex` extension of `markdown.value` states it (<https://hl7.org/fhir/R5/datatypes.html#primitive>),
/// and the form is an XML Schema pattern, where `\s` is the space, the tab,
/// the carriage return and the line feed alone (<https://www.w3.org/TR/xmlschema-2/#regexs>).
#[expect(
    clippy::expect_used,
    reason = "the emitter compiles every lexical form it writes, so the pattern holds"
)]
static MARKDOWN_LEXICAL_FORM: std::sync::LazyLock<regex::bytes::Regex> =
    std::sync::LazyLock::new(|| {
        regex::bytes::RegexBuilder::new(r"^(?:^[\s\S]+$)$")
            .unicode(false)
            .build()
            .expect("the lexical form of `markdown` should compile")
    });

/// Hands back `text` when it keeps the lexical form of `markdown`.
///
/// # Errors
///
/// Returns [`super::super::codec::DecodeErrorKind::BadValue`] at `path` for a value outside the form.
pub(crate) fn checked_markdown(
    text: std::string::String,
    path: &super::super::codec::Path,
) -> Result<std::string::String, super::super::codec::DecodeError> {
    if MARKDOWN_LEXICAL_FORM.is_match(text.as_bytes()) {
        Ok(text)
    } else {
        Err(path.error(super::super::codec::DecodeErrorKind::BadValue))
    }
}

impl super::super::codec::Primitive for Markdown {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::String(v.clone())))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_str(serializer, v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(checked_markdown(
                    super::super::codec::expect_string(value, path)?,
                    path,
                )?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type oid
///
/// An OID represented as a URI
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Oid {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for oid
    pub value: Option<std::string::String>,
}
impl From<std::string::String> for Oid {
    fn from(value: std::string::String) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}
impl From<&str> for Oid {
    fn from(value: &str) -> Self {
        Self::from(std::string::String::from(value))
    }
}

/// The lexical form of the FHIR primitive `oid`, anchored to the whole value.
///
/// The `regex` extension of `oid.value` states it (<https://hl7.org/fhir/R5/datatypes.html#primitive>),
/// and the form is an XML Schema pattern, where `\s` is the space, the tab,
/// the carriage return and the line feed alone (<https://www.w3.org/TR/xmlschema-2/#regexs>).
#[expect(
    clippy::expect_used,
    reason = "the emitter compiles every lexical form it writes, so the pattern holds"
)]
static OID_LEXICAL_FORM: std::sync::LazyLock<regex::bytes::Regex> =
    std::sync::LazyLock::new(|| {
        regex::bytes::RegexBuilder::new(r"^(?:urn:oid:[0-2](\.(0|[1-9][0-9]*))+)$")
            .unicode(false)
            .build()
            .expect("the lexical form of `oid` should compile")
    });

/// Hands back `text` when it keeps the lexical form of `oid`.
///
/// # Errors
///
/// Returns [`super::super::codec::DecodeErrorKind::BadValue`] at `path` for a value outside the form.
pub(crate) fn checked_oid(
    text: std::string::String,
    path: &super::super::codec::Path,
) -> Result<std::string::String, super::super::codec::DecodeError> {
    if OID_LEXICAL_FORM.is_match(text.as_bytes()) {
        Ok(text)
    } else {
        Err(path.error(super::super::codec::DecodeErrorKind::BadValue))
    }
}

impl super::super::codec::Primitive for Oid {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::String(v.clone())))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_str(serializer, v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(checked_oid(
                    super::super::codec::expect_string(value, path)?,
                    path,
                )?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type positiveInt
///
/// An integer with a value that is positive (e.g. \>0)
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct PositiveInt {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for positiveInt
    pub value: Option<u32>,
}
impl From<u32> for PositiveInt {
    fn from(value: u32) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}

impl super::super::codec::Primitive for PositiveInt {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::from(*v)))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_u32(serializer, *v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(super::super::codec::expect_u32(value, 1, path)?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type string
///
/// A sequence of Unicode characters
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct String {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for string
    ///
    /// The actual value
    pub value: Option<std::string::String>,
}
impl From<std::string::String> for String {
    fn from(value: std::string::String) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}
impl From<&str> for String {
    fn from(value: &str) -> Self {
        Self::from(std::string::String::from(value))
    }
}

/// The lexical form of the FHIR primitive `string`, anchored to the whole value.
///
/// The `regex` extension of `string.value` states it (<https://hl7.org/fhir/R5/datatypes.html#primitive>),
/// and the form is an XML Schema pattern, where `\s` is the space, the tab,
/// the carriage return and the line feed alone (<https://www.w3.org/TR/xmlschema-2/#regexs>).
#[expect(
    clippy::expect_used,
    reason = "the emitter compiles every lexical form it writes, so the pattern holds"
)]
static STRING_LEXICAL_FORM: std::sync::LazyLock<regex::bytes::Regex> =
    std::sync::LazyLock::new(|| {
        regex::bytes::RegexBuilder::new(r"^(?:^[\s\S]+$)$")
            .unicode(false)
            .build()
            .expect("the lexical form of `string` should compile")
    });

/// Hands back `text` when it keeps the lexical form of `string`.
///
/// # Errors
///
/// Returns [`super::super::codec::DecodeErrorKind::BadValue`] at `path` for a value outside the form.
pub(crate) fn checked_string(
    text: std::string::String,
    path: &super::super::codec::Path,
) -> Result<std::string::String, super::super::codec::DecodeError> {
    if STRING_LEXICAL_FORM.is_match(text.as_bytes()) {
        Ok(text)
    } else {
        Err(path.error(super::super::codec::DecodeErrorKind::BadValue))
    }
}

impl super::super::codec::Primitive for String {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::String(v.clone())))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_str(serializer, v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(checked_string(
                    super::super::codec::expect_string(value, path)?,
                    path,
                )?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type time
///
/// A time during the day, with no date specified
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Time {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for time
    ///
    /// The actual value
    pub value: Option<std::string::String>,
}
impl From<std::string::String> for Time {
    fn from(value: std::string::String) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}
impl From<&str> for Time {
    fn from(value: &str) -> Self {
        Self::from(std::string::String::from(value))
    }
}

/// The lexical form of the FHIR primitive `time`, anchored to the whole value.
///
/// The `regex` extension of `time.value` states it (<https://hl7.org/fhir/R5/datatypes.html#primitive>),
/// and the form is an XML Schema pattern, where `\s` is the space, the tab,
/// the carriage return and the line feed alone (<https://www.w3.org/TR/xmlschema-2/#regexs>).
#[expect(
    clippy::expect_used,
    reason = "the emitter compiles every lexical form it writes, so the pattern holds"
)]
static TIME_LEXICAL_FORM: std::sync::LazyLock<regex::bytes::Regex> =
    std::sync::LazyLock::new(|| {
        regex::bytes::RegexBuilder::new(
            r"^(?:([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]{1,9})?)$",
        )
        .unicode(false)
        .build()
        .expect("the lexical form of `time` should compile")
    });

/// Hands back `text` when it keeps the lexical form of `time`.
///
/// # Errors
///
/// Returns [`super::super::codec::DecodeErrorKind::BadValue`] at `path` for a value outside the form.
pub(crate) fn checked_time(
    text: std::string::String,
    path: &super::super::codec::Path,
) -> Result<std::string::String, super::super::codec::DecodeError> {
    if TIME_LEXICAL_FORM.is_match(text.as_bytes()) {
        Ok(text)
    } else {
        Err(path.error(super::super::codec::DecodeErrorKind::BadValue))
    }
}

impl super::super::codec::Primitive for Time {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::String(v.clone())))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_str(serializer, v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(checked_time(
                    super::super::codec::expect_string(value, path)?,
                    path,
                )?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type unsignedInt
///
/// An integer with a value that is not negative (e.g. \>= 0)
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct UnsignedInt {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for unsignedInt
    pub value: Option<u32>,
}
impl From<u32> for UnsignedInt {
    fn from(value: u32) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}

impl super::super::codec::Primitive for UnsignedInt {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::from(*v)))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_u32(serializer, *v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(super::super::codec::expect_u32(value, 0, path)?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type uri
///
/// String of characters used to identify a name or a resource
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Uri {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for uri
    ///
    /// The actual value
    pub value: Option<std::string::String>,
}
impl From<std::string::String> for Uri {
    fn from(value: std::string::String) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}
impl From<&str> for Uri {
    fn from(value: &str) -> Self {
        Self::from(std::string::String::from(value))
    }
}

/// The lexical form of the FHIR primitive `uri`, anchored to the whole value.
///
/// The `regex` extension of `uri.value` states it (<https://hl7.org/fhir/R5/datatypes.html#primitive>),
/// and the form is an XML Schema pattern, where `\s` is the space, the tab,
/// the carriage return and the line feed alone (<https://www.w3.org/TR/xmlschema-2/#regexs>).
#[expect(
    clippy::expect_used,
    reason = "the emitter compiles every lexical form it writes, so the pattern holds"
)]
static URI_LEXICAL_FORM: std::sync::LazyLock<regex::bytes::Regex> =
    std::sync::LazyLock::new(|| {
        regex::bytes::RegexBuilder::new(r"^(?:\S*)$")
            .unicode(false)
            .build()
            .expect("the lexical form of `uri` should compile")
    });

/// Hands back `text` when it keeps the lexical form of `uri`.
///
/// # Errors
///
/// Returns [`super::super::codec::DecodeErrorKind::BadValue`] at `path` for a value outside the form.
pub(crate) fn checked_uri(
    text: std::string::String,
    path: &super::super::codec::Path,
) -> Result<std::string::String, super::super::codec::DecodeError> {
    if URI_LEXICAL_FORM.is_match(text.as_bytes()) {
        Ok(text)
    } else {
        Err(path.error(super::super::codec::DecodeErrorKind::BadValue))
    }
}

impl super::super::codec::Primitive for Uri {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::String(v.clone())))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_str(serializer, v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(checked_uri(
                    super::super::codec::expect_string(value, path)?,
                    path,
                )?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type url
///
/// A URI that is a literal reference
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Url {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for url
    pub value: Option<std::string::String>,
}
impl From<std::string::String> for Url {
    fn from(value: std::string::String) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}
impl From<&str> for Url {
    fn from(value: &str) -> Self {
        Self::from(std::string::String::from(value))
    }
}

/// The lexical form of the FHIR primitive `url`, anchored to the whole value.
///
/// The `regex` extension of `url.value` states it (<https://hl7.org/fhir/R5/datatypes.html#primitive>),
/// and the form is an XML Schema pattern, where `\s` is the space, the tab,
/// the carriage return and the line feed alone (<https://www.w3.org/TR/xmlschema-2/#regexs>).
#[expect(
    clippy::expect_used,
    reason = "the emitter compiles every lexical form it writes, so the pattern holds"
)]
static URL_LEXICAL_FORM: std::sync::LazyLock<regex::bytes::Regex> =
    std::sync::LazyLock::new(|| {
        regex::bytes::RegexBuilder::new(r"^(?:\S*)$")
            .unicode(false)
            .build()
            .expect("the lexical form of `url` should compile")
    });

/// Hands back `text` when it keeps the lexical form of `url`.
///
/// # Errors
///
/// Returns [`super::super::codec::DecodeErrorKind::BadValue`] at `path` for a value outside the form.
pub(crate) fn checked_url(
    text: std::string::String,
    path: &super::super::codec::Path,
) -> Result<std::string::String, super::super::codec::DecodeError> {
    if URL_LEXICAL_FORM.is_match(text.as_bytes()) {
        Ok(text)
    } else {
        Err(path.error(super::super::codec::DecodeErrorKind::BadValue))
    }
}

impl super::super::codec::Primitive for Url {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::String(v.clone())))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_str(serializer, v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(checked_url(
                    super::super::codec::expect_string(value, path)?,
                    path,
                )?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type uuid
///
/// A UUID, represented as a URI
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Uuid {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    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 resource. 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>,
    /// Primitive value for uuid
    pub value: Option<std::string::String>,
}
impl From<std::string::String> for Uuid {
    fn from(value: std::string::String) -> Self {
        Self {
            value: Some(value),
            ..Self::default()
        }
    }
}
impl From<&str> for Uuid {
    fn from(value: &str) -> Self {
        Self::from(std::string::String::from(value))
    }
}

/// The lexical form of the FHIR primitive `uuid`, anchored to the whole value.
///
/// The `regex` extension of `uuid.value` states it (<https://hl7.org/fhir/R5/datatypes.html#primitive>),
/// and the form is an XML Schema pattern, where `\s` is the space, the tab,
/// the carriage return and the line feed alone (<https://www.w3.org/TR/xmlschema-2/#regexs>).
#[expect(
    clippy::expect_used,
    reason = "the emitter compiles every lexical form it writes, so the pattern holds"
)]
static UUID_LEXICAL_FORM: std::sync::LazyLock<regex::bytes::Regex> =
    std::sync::LazyLock::new(|| {
        regex::bytes::RegexBuilder::new(
            r"^(?:urn:uuid:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$",
        )
        .unicode(false)
        .build()
        .expect("the lexical form of `uuid` should compile")
    });

/// Hands back `text` when it keeps the lexical form of `uuid`.
///
/// # Errors
///
/// Returns [`super::super::codec::DecodeErrorKind::BadValue`] at `path` for a value outside the form.
pub(crate) fn checked_uuid(
    text: std::string::String,
    path: &super::super::codec::Path,
) -> Result<std::string::String, super::super::codec::DecodeError> {
    if UUID_LEXICAL_FORM.is_match(text.as_bytes()) {
        Ok(text)
    } else {
        Err(path.error(super::super::codec::DecodeErrorKind::BadValue))
    }
}

impl super::super::codec::Primitive for Uuid {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(self
            .value
            .as_ref()
            .map(|v| super::super::codec::Value::String(v.clone())))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() && self.extension.is_empty() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.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),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        self.value.is_some()
    }

    fn has_element(&self) -> bool {
        self.id.is_some() || !self.extension.is_empty()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self.value.as_ref() {
            Some(v) => serde::Serializer::serialize_str(serializer, v),
            None => serde::Serializer::serialize_none(serializer),
        }
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() && self.extension.is_empty() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(checked_uuid(
                    super::super::codec::expect_string(value, path)?,
                    path,
                )?)
            }
            None => None,
        };
        let mut id = None;
        let mut extension = Vec::new();
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    "extension" => {
                        for (index, entry) in super::super::codec::expect_array(item, path)?
                            .iter()
                            .enumerate()
                        {
                            extension.push(path.with_index("extension", index, |path| {
                                super::super::codec::Json::from_json(
                                    super::super::codec::expect_object(entry, path)?,
                                    path,
                                )
                            })?);
                        }
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self {
            id,
            extension,
            value,
        })
    }
}

/// Primitive Type xhtml
///
/// XHTML
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Xhtml {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references)
    pub id: Option<std::string::String>,
    /// Actual xhtml
    pub value: std::string::String,
}
impl From<std::string::String> for Xhtml {
    fn from(value: std::string::String) -> Self {
        Self {
            value,
            ..Self::default()
        }
    }
}
impl From<&str> for Xhtml {
    fn from(value: &str) -> Self {
        Self::from(std::string::String::from(value))
    }
}

impl super::super::codec::Primitive for Xhtml {
    fn value_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        Ok(Some(&self.value).map(|v| super::super::codec::Value::String(v.clone())))
    }

    fn element_json(
        &self,
    ) -> Result<Option<super::super::codec::Value>, super::super::codec::EncodeError> {
        if self.id.is_none() {
            return Ok(None);
        }
        let mut object = super::super::codec::Object::new();
        if let Some(id) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(id.clone()),
            );
        }
        Ok(Some(super::super::codec::Value::Object(object)))
    }

    fn has_value(&self) -> bool {
        true
    }

    fn has_element(&self) -> bool {
        self.id.is_some()
    }

    fn serialize_value<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serde::Serializer::serialize_str(serializer, &self.value)
    }

    fn serialize_element<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        if self.id.is_none() {
            return serde::Serializer::serialize_none(serializer);
        }
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if let Some(id) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", id)?;
        }
        serde::ser::SerializeMap::end(map)
    }

    fn from_json_parts(
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        if value.is_none() && element.is_none() && !path.is_lenient() {
            return Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty));
        }
        let value = match value {
            Some(value) => {
                let value = super::super::codec::expect_single(value, path)?;
                Some(super::super::codec::expect_string(value, path)?)
            }
            None => None,
        };
        let value = value
            .ok_or_else(|| path.error(super::super::codec::DecodeErrorKind::MissingProperty))?;
        let mut id = None;
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            for (key, item) in object {
                match key.as_str() {
                    "id" => {
                        id = Some(path.with("id", |path| {
                            super::primitives::checked_string(
                                super::super::codec::expect_string(item, path)?,
                                path,
                            )
                        })?);
                    }
                    _ => {
                        return path.with(key, |path| {
                            Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                        });
                    }
                }
            }
        }
        Ok(Self { id, value })
    }
}