fhir-types 0.1.98

// @generated by fhir-codegen from hl7.fhir.r6.core 6.0.0-ballot5. DO NOT EDIT.
// Change the emitter (tools/fhir-codegen) and regenerate.
//! The FHIR primitive types (<https://hl7.org/fhir/R6/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))
    }
}

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(super::super::codec::expect_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::super::codec::expect_string(item, 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::super::codec::expect_string(item, 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))
    }
}

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(super::super::codec::expect_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::super::codec::expect_string(item, 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))
    }
}

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(super::super::codec::expect_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::super::codec::expect_string(item, 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))
    }
}

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(super::super::codec::expect_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::super::codec::expect_string(item, 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))
    }
}

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(super::super::codec::expect_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::super::codec::expect_string(item, 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::super::codec::expect_string(item, 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.) No whitespace characters
/// are allowed. 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))
    }
}

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(super::super::codec::expect_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::super::codec::expect_string(item, 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))
    }
}

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(super::super::codec::expect_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::super::codec::expect_string(item, 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::super::codec::expect_string(item, 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::super::codec::expect_string(item, 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))
    }
}

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(super::super::codec::expect_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::super::codec::expect_string(item, 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))
    }
}

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(super::super::codec::expect_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::super::codec::expect_string(item, 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::super::codec::expect_string(item, 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))
    }
}

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(super::super::codec::expect_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::super::codec::expect_string(item, 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))
    }
}

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(super::super::codec::expect_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::super::codec::expect_string(item, 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::super::codec::expect_string(item, 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))
    }
}

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(super::super::codec::expect_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::super::codec::expect_string(item, 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))
    }
}

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(super::super::codec::expect_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::super::codec::expect_string(item, 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))
    }
}

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(super::super::codec::expect_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::super::codec::expect_string(item, 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 {
    /// Actual xhtml
    pub value: std::string::String,
}
impl From<std::string::String> for Xhtml {
    fn from(value: std::string::String) -> Self {
        Self { value }
    }
}
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> {
        Ok(None)
    }

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

    fn has_element(&self) -> bool {
        false
    }

    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> {
        serde::Serializer::serialize_none(serializer)
    }

    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))?;
        if let Some(element) = element {
            let object = super::super::codec::expect_object(element, path)?;
            if let Some(key) = object.keys().next() {
                return path.with(key, |path| {
                    Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                });
            }
        }
        Ok(Self { value })
    }
}