openehr-am 0.0.78

// @generated by openehr-codegen (emit-json) — DO NOT EDIT.
// SPDX-FileCopyrightText: Vernum Projecten B.V.
// SPDX-FileCopyrightText: openEHR Foundation
// SPDX-License-Identifier: Apache-2.0
//! Canonical-JSON `serde::Serialize`/`serde::Deserialize` impls for this
//! crate's generated spec types.
//!
//! Manual (never derived) long-form impls per
//! <https://serde.rs/deserialize-struct.html>: the canonical wire's
//! `_type` discriminator, its context-dependent presence, deep-descendant
//! dispatch and closed key set are not expressible with serde attributes.
//! The shared runtime is `openehr_base::serde_support`.

#![allow(
    clippy::all,
    clippy::pedantic,
    clippy::nursery,
    unused_variables,
    unused_mut,
    unused_qualifications,
    reason = "mechanically generated codec text: every item is named by its full path and every branch shape is emitted uniformly, so style and unused-binding lints do not apply — the hand-written runtime carries the lint bar"
)]

impl ::serde::Serialize for crate::v1_4::aom14::archetype::archetype::Archetype {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 6usize;
        if self.uid.is_some() {
            __n += 1;
        }
        if self.description.is_some() {
            __n += 1;
        }
        if self.is_controlled.is_some() {
            __n += 1;
        }
        if self.annotations.is_some() {
            __n += 1;
        }
        if self.translations.is_some() {
            __n += 1;
        }
        if self.adl_version.is_some() {
            __n += 1;
        }
        if self.parent_archetype_id.is_some() {
            __n += 1;
        }
        if self.invariants.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "ARCHETYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "ARCHETYPE")?;
        if let Some(__v) = &self.uid {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "uid", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "original_language",
            &self.original_language,
        )?;
        if let Some(__v) = &self.description {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "description", __v)?;
        }
        if let Some(__v) = &self.is_controlled {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_controlled", __v)?;
        }
        if let Some(__v) = &self.annotations {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "annotations", __v)?;
        }
        if let Some(__v) = &self.translations {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "translations", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", &self.definition)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "ontology", &self.ontology)?;
        if let Some(__v) = &self.adl_version {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "adl_version", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "archetype_id",
            &self.archetype_id,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "concept", &self.concept)?;
        if let Some(__v) = &self.parent_archetype_id {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent_archetype_id", __v)?;
        }
        if let Some(__v) = &self.invariants
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "invariants", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_4::aom14::archetype::archetype::Archetype {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "adl_version",
            "annotations",
            "archetype_id",
            "concept",
            "definition",
            "description",
            "invariants",
            "is_controlled",
            "ontology",
            "original_language",
            "parent_archetype_id",
            "translations",
            "uid",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "uid" => ::core::result::Result::Ok(__Field::__F0),
                            "original_language" => ::core::result::Result::Ok(__Field::__F1),
                            "description" => ::core::result::Result::Ok(__Field::__F2),
                            "is_controlled" => ::core::result::Result::Ok(__Field::__F3),
                            "annotations" => ::core::result::Result::Ok(__Field::__F4),
                            "translations" => ::core::result::Result::Ok(__Field::__F5),
                            "definition" => ::core::result::Result::Ok(__Field::__F6),
                            "ontology" => ::core::result::Result::Ok(__Field::__F7),
                            "adl_version" => ::core::result::Result::Ok(__Field::__F8),
                            "archetype_id" => ::core::result::Result::Ok(__Field::__F9),
                            "concept" => ::core::result::Result::Ok(__Field::__F10),
                            "parent_archetype_id" => ::core::result::Result::Ok(__Field::__F11),
                            "invariants" => ::core::result::Result::Ok(__Field::__F12),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "ARCHETYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::archetype::Archetype;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ARCHETYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("ARCHETYPE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("uid"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("original_language"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("description"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_controlled"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("annotations"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("translations"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("definition"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("ontology"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("adl_version"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("archetype_id"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("concept"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent_archetype_id"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("invariants"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_4::aom14::archetype::archetype::Archetype {
                    uid: __s0.flatten(),
                    original_language: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("original_language"))?,
                    description: __s2.flatten(),
                    is_controlled: __s3.flatten(),
                    annotations: __s4.flatten(),
                    translations: __s5.flatten(),
                    definition: __s6
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("definition"))?,
                    ontology: __s7
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("ontology"))?,
                    adl_version: __s8.flatten(),
                    archetype_id: __s9
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("archetype_id"))?,
                    concept: __s10
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("concept"))?,
                    parent_archetype_id: __s11.flatten(),
                    invariants: __s12,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "ARCHETYPE", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::ArchetypeInternalRef(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::ArchetypeSlot(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::ConstraintRef(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::CCodedText(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::CComplexObject(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::CMultipleAttribute(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::COrdinal(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::CPrimitiveObject(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::CQuantity(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::CSingleAttribute(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "ARCHETYPE_INTERNAL_REF",
            "ARCHETYPE_SLOT",
            "CONSTRAINT_REF",
            "C_CODED_TEXT",
            "C_COMPLEX_OBJECT",
            "C_MULTIPLE_ATTRIBUTE",
            "C_ORDINAL",
            "C_PRIMITIVE_OBJECT",
            "C_QUANTITY",
            "C_SINGLE_ATTRIBUTE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ARCHETYPE_CONSTRAINT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"ARCHETYPE_INTERNAL_REF" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::ArchetypeInternalRef(::serde::Deserialize::deserialize(__rest)?)),
"ARCHETYPE_SLOT" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::ArchetypeSlot(::serde::Deserialize::deserialize(__rest)?)),
"CONSTRAINT_REF" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::ConstraintRef(::serde::Deserialize::deserialize(__rest)?)),
"C_CODED_TEXT" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::CCodedText(::serde::Deserialize::deserialize(__rest)?)),
"C_COMPLEX_OBJECT" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::CComplexObject(::serde::Deserialize::deserialize(__rest)?)),
"C_MULTIPLE_ATTRIBUTE" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::CMultipleAttribute(::serde::Deserialize::deserialize(__rest)?)),
"C_ORDINAL" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::COrdinal(::serde::Deserialize::deserialize(__rest)?)),
"C_PRIMITIVE_OBJECT" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::CPrimitiveObject(::serde::Deserialize::deserialize(__rest)?)),
"C_QUANTITY" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::CQuantity(::serde::Deserialize::deserialize(__rest)?)),
"C_SINGLE_ATTRIBUTE" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::archetype_constraint::ArchetypeConstraint::CSingleAttribute(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("ARCHETYPE_CONSTRAINT", __other, "ARCHETYPE_INTERNAL_REF, ARCHETYPE_SLOT, CONSTRAINT_REF, C_CODED_TEXT, C_COMPLEX_OBJECT, C_MULTIPLE_ATTRIBUTE, C_ORDINAL, C_PRIMITIVE_OBJECT, C_QUANTITY, C_SINGLE_ATTRIBUTE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "ARCHETYPE_CONSTRAINT",
                            &__other,
                            "ARCHETYPE_INTERNAL_REF, ARCHETYPE_SLOT, CONSTRAINT_REF, C_CODED_TEXT, C_COMPLEX_OBJECT, C_MULTIPLE_ATTRIBUTE, C_ORDINAL, C_PRIMITIVE_OBJECT, C_QUANTITY, C_SINGLE_ATTRIBUTE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "ARCHETYPE_CONSTRAINT",
                            "ARCHETYPE_INTERNAL_REF, ARCHETYPE_SLOT, CONSTRAINT_REF, C_CODED_TEXT, C_COMPLEX_OBJECT, C_MULTIPLE_ATTRIBUTE, C_ORDINAL, C_PRIMITIVE_OBJECT, C_QUANTITY, C_SINGLE_ATTRIBUTE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::archetype::constraint_model::archetype_internal_ref::ArchetypeInternalRef {
fn serialize<__S: ::serde::Serializer>(&self, __serializer: __S) -> ::core::result::Result<__S::Ok, __S::Error> {
let mut __n = 5usize;
let mut __st = ::serde::Serializer::serialize_struct(__serializer, "ARCHETYPE_INTERNAL_REF", __n)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "ARCHETYPE_INTERNAL_REF")?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_type_name", &self.rm_type_name)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", &self.occurrences)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "target_path", &self.target_path)?;
::serde::ser::SerializeStruct::end(__st)
}
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_4::aom14::archetype::constraint_model::archetype_internal_ref::ArchetypeInternalRef {
fn deserialize<__D: ::serde::Deserializer<'de>>(__deserializer: __D) -> ::core::result::Result<Self, __D::Error> {
const __FIELDS: &[&str] = &["node_id", "occurrences", "rm_type_name", "target_path"];
enum __Field { __Type, __F0, __F1, __F2, __F3, }
impl<'de> ::serde::Deserialize<'de> for __Field {
fn deserialize<__D: ::serde::Deserializer<'de>>(__deserializer: __D) -> ::core::result::Result<Self, __D::Error> {
struct __KeyVisitor;
impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
type Value = __Field;
fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
__f.write_str("an object member name")
}
fn visit_str<__E: ::serde::de::Error>(self, __v: &str) -> ::core::result::Result<__Field, __E> {
match __v {
"_type" => ::core::result::Result::Ok(__Field::__Type),
"rm_type_name" => ::core::result::Result::Ok(__Field::__F0),
"occurrences" => ::core::result::Result::Ok(__Field::__F1),
"node_id" => ::core::result::Result::Ok(__Field::__F2),
"target_path" => ::core::result::Result::Ok(__Field::__F3),
_ => ::core::result::Result::Err(::openehr_base::serde_support::unknown_field(__v, "ARCHETYPE_INTERNAL_REF", __FIELDS)),
}
}
}
::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
}
}
struct __Visitor;
impl<'de> ::serde::de::Visitor<'de> for __Visitor {
type Value = crate::v1_4::aom14::archetype::constraint_model::archetype_internal_ref::ArchetypeInternalRef;
fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
__f.write_str("an openEHR `ARCHETYPE_INTERNAL_REF` object")
}
fn visit_map<__A: ::serde::de::MapAccess<'de>>(self, mut __map: __A) -> ::core::result::Result<Self::Value, __A::Error> {
let mut __seen_type = false;
let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
 match __key {
__Field::__Type => {
if __seen_type { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("_type")); }
__seen_type = true;
::serde::de::MapAccess::next_value_seed(&mut __map, ::openehr_base::serde_support::ExpectedType("ARCHETYPE_INTERNAL_REF"))?;
}
__Field::__F0 => {
if __s0.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("rm_type_name")); }
__s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F1 => {
if __s1.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("occurrences")); }
__s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F2 => {
if __s2.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("node_id")); }
__s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F3 => {
if __s3.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("target_path")); }
__s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
}
}
::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::archetype_internal_ref::ArchetypeInternalRef {
rm_type_name: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
occurrences: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("occurrences"))?,
node_id: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
target_path: __s3.flatten().ok_or_else(|| ::serde::de::Error::missing_field("target_path"))?,
})
}
}
::serde::Deserializer::deserialize_struct(__deserializer, "ARCHETYPE_INTERNAL_REF", __FIELDS, __Visitor)
}
}

impl ::serde::Serialize
    for crate::v1_4::aom14::archetype::ontology::archetype_ontology::ArchetypeOntology
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self
            .terminologies_available
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "ARCHETYPE_ONTOLOGY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "ARCHETYPE_ONTOLOGY")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "term_codes", &self.term_codes)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "constraint_codes",
            &self.constraint_codes,
        )?;
        if let Some(__v) = &self.terminologies_available
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "terminologies_available",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "specialisation_depth",
            &self.specialisation_depth,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "term_attribute_names",
            &self.term_attribute_names,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::ontology::archetype_ontology::ArchetypeOntology
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "constraint_codes",
            "specialisation_depth",
            "term_attribute_names",
            "term_codes",
            "terminologies_available",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "term_codes" => ::core::result::Result::Ok(__Field::__F0),
                            "constraint_codes" => ::core::result::Result::Ok(__Field::__F1),
                            "terminologies_available" => ::core::result::Result::Ok(__Field::__F2),
                            "specialisation_depth" => ::core::result::Result::Ok(__Field::__F3),
                            "term_attribute_names" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "ARCHETYPE_ONTOLOGY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_4::aom14::archetype::ontology::archetype_ontology::ArchetypeOntology;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ARCHETYPE_ONTOLOGY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<_> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("ARCHETYPE_ONTOLOGY"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("term_codes"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constraint_codes"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("terminologies_available"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("specialisation_depth"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("term_attribute_names"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_4::aom14::archetype::ontology::archetype_ontology::ArchetypeOntology {
term_codes: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("term_codes"))?,
constraint_codes: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("constraint_codes"))?,
terminologies_available: __s2,
specialisation_depth: __s3.flatten().ok_or_else(|| ::serde::de::Error::missing_field("specialisation_depth"))?,
term_attribute_names: __s4.flatten().ok_or_else(|| ::serde::de::Error::missing_field("term_attribute_names"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "ARCHETYPE_ONTOLOGY",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_4::aom14::archetype::constraint_model::archetype_slot::ArchetypeSlot
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.includes.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.excludes.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "ARCHETYPE_SLOT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "ARCHETYPE_SLOT")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "occurrences",
            &self.occurrences,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.includes
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "includes", __v)?;
        }
        if let Some(__v) = &self.excludes
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "excludes", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::constraint_model::archetype_slot::ArchetypeSlot
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "excludes",
            "includes",
            "node_id",
            "occurrences",
            "rm_type_name",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F1),
                            "node_id" => ::core::result::Result::Ok(__Field::__F2),
                            "includes" => ::core::result::Result::Ok(__Field::__F3),
                            "excludes" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "ARCHETYPE_SLOT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_4::aom14::archetype::constraint_model::archetype_slot::ArchetypeSlot;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ARCHETYPE_SLOT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<_> = None;
                let mut __s4: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("ARCHETYPE_SLOT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("includes"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("excludes"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::archetype_slot::ArchetypeSlot {
rm_type_name: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
occurrences: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("occurrences"))?,
node_id: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
includes: __s3,
excludes: __s4,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "ARCHETYPE_SLOT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::archetype::ontology::archetype_term::ArchetypeTerm {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.items.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "ARCHETYPE_TERM", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "ARCHETYPE_TERM")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "code", &self.code)?;
        if let Some(__v) = &self.items {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "items", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::ontology::archetype_term::ArchetypeTerm
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["code", "items"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "code" => ::core::result::Result::Ok(__Field::__F0),
                            "items" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "ARCHETYPE_TERM",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::ontology::archetype_term::ArchetypeTerm;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ARCHETYPE_TERM` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("ARCHETYPE_TERM"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("code"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("items"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::aom14::archetype::ontology::archetype_term::ArchetypeTerm {
                        code: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("code"))?,
                        items: __s1.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "ARCHETYPE_TERM",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::archetype::assertion::assertion::Assertion {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.tag.is_some() {
            __n += 1;
        }
        if self.string_expression.is_some() {
            __n += 1;
        }
        if self.variables.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "ASSERTION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "ASSERTION")?;
        if let Some(__v) = &self.tag {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "tag", __v)?;
        }
        if let Some(__v) = &self.string_expression {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "string_expression", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "expression", &self.expression)?;
        if let Some(__v) = &self.variables
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "variables", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::assertion::assertion::Assertion
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["expression", "string_expression", "tag", "variables"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "tag" => ::core::result::Result::Ok(__Field::__F0),
                            "string_expression" => ::core::result::Result::Ok(__Field::__F1),
                            "expression" => ::core::result::Result::Ok(__Field::__F2),
                            "variables" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "ASSERTION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::assertion::assertion::Assertion;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ASSERTION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("ASSERTION"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("tag"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("string_expression"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("expression"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("variables"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::aom14::archetype::assertion::assertion::Assertion {
                        tag: __s0.flatten(),
                        string_expression: __s1.flatten(),
                        expression: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("expression"))?,
                        variables: __s3,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "ASSERTION", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_4::aom14::archetype::assertion::assertion_variable::AssertionVariable
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "ASSERTION_VARIABLE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "ASSERTION_VARIABLE")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", &self.definition)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::assertion::assertion_variable::AssertionVariable
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["definition", "name"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "definition" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "ASSERTION_VARIABLE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_4::aom14::archetype::assertion::assertion_variable::AssertionVariable;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ASSERTION_VARIABLE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("ASSERTION_VARIABLE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("definition"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_4::aom14::archetype::assertion::assertion_variable::AssertionVariable {
name: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
definition: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("definition"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "ASSERTION_VARIABLE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_4::resource::authored_resource::AuthoredResource {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_4::resource::authored_resource::AuthoredResource::Archetype(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_4::resource::authored_resource::AuthoredResource {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["ARCHETYPE"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::resource::authored_resource::AuthoredResource;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `AUTHORED_RESOURCE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"ARCHETYPE" => ::core::result::Result::Ok(crate::v1_4::resource::authored_resource::AuthoredResource::Archetype(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("AUTHORED_RESOURCE", __other, "ARCHETYPE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "AUTHORED_RESOURCE",
                            &__other,
                            "ARCHETYPE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "AUTHORED_RESOURCE",
                            "ARCHETYPE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_4::aom14::archetype::constraint_model::cardinality::Cardinality
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "CARDINALITY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "CARDINALITY")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "interval", &self.interval)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_ordered", &self.is_ordered)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_unique", &self.is_unique)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::constraint_model::cardinality::Cardinality
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["interval", "is_ordered", "is_unique"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "interval" => ::core::result::Result::Ok(__Field::__F0),
                            "is_ordered" => ::core::result::Result::Ok(__Field::__F1),
                            "is_unique" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "CARDINALITY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::constraint_model::cardinality::Cardinality;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `CARDINALITY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("CARDINALITY"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("interval"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_ordered"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_unique"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::aom14::archetype::constraint_model::cardinality::Cardinality {
                        interval: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("interval"))?,
                        is_ordered: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_ordered"))?,
                        is_unique: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_unique"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "CARDINALITY",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_4::aom14::archetype::constraint_model::constraint_ref::ConstraintRef
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "CONSTRAINT_REF", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "CONSTRAINT_REF")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "occurrences",
            &self.occurrences,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "reference", &self.reference)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::constraint_model::constraint_ref::ConstraintRef
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["node_id", "occurrences", "reference", "rm_type_name"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F1),
                            "node_id" => ::core::result::Result::Ok(__Field::__F2),
                            "reference" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "CONSTRAINT_REF",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_4::aom14::archetype::constraint_model::constraint_ref::ConstraintRef;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `CONSTRAINT_REF` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("CONSTRAINT_REF"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("reference"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::constraint_ref::ConstraintRef {
rm_type_name: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
occurrences: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("occurrences"))?,
node_id: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
reference: __s3.flatten().ok_or_else(|| ::serde::de::Error::missing_field("reference"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "CONSTRAINT_REF",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_4::aom14::archetype::constraint_model::c_attribute::CAttribute
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_4::aom14::archetype::constraint_model::c_attribute::CAttribute::CMultipleAttribute(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::c_attribute::CAttribute::CSingleAttribute(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::constraint_model::c_attribute::CAttribute
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["C_MULTIPLE_ATTRIBUTE", "C_SINGLE_ATTRIBUTE"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::constraint_model::c_attribute::CAttribute;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_ATTRIBUTE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"C_MULTIPLE_ATTRIBUTE" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_attribute::CAttribute::CMultipleAttribute(::serde::Deserialize::deserialize(__rest)?)),
"C_SINGLE_ATTRIBUTE" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_attribute::CAttribute::CSingleAttribute(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("C_ATTRIBUTE", __other, "C_MULTIPLE_ATTRIBUTE, C_SINGLE_ATTRIBUTE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "C_ATTRIBUTE",
                            &__other,
                            "C_MULTIPLE_ATTRIBUTE, C_SINGLE_ATTRIBUTE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "C_ATTRIBUTE",
                            "C_MULTIPLE_ATTRIBUTE, C_SINGLE_ATTRIBUTE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::archetype::primitive::c_boolean::CBoolean {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.assumed_value.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_BOOLEAN", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_BOOLEAN")?;
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "true_valid", &self.true_valid)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "false_valid",
            &self.false_valid,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::primitive::c_boolean::CBoolean
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["assumed_value", "false_valid", "true_valid"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F0),
                            "true_valid" => ::core::result::Result::Ok(__Field::__F1),
                            "false_valid" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_BOOLEAN",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::primitive::c_boolean::CBoolean;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_BOOLEAN` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_BOOLEAN"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("true_valid"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("false_valid"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::aom14::archetype::primitive::c_boolean::CBoolean {
                        assumed_value: __s0.flatten(),
                        true_valid: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("true_valid"))?,
                        false_valid: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("false_valid"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "C_BOOLEAN", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_4::aom14::openehr_archetype_profile::c_coded_text::CCodedText
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.code_list.is_some() {
            __n += 1;
        }
        if self.reference.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_CODED_TEXT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_CODED_TEXT")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "occurrences",
            &self.occurrences,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "terminology",
            &self.terminology,
        )?;
        if let Some(__v) = &self.code_list {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "code_list", __v)?;
        }
        if let Some(__v) = &self.reference {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "reference", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::openehr_archetype_profile::c_coded_text::CCodedText
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "assumed_value",
            "code_list",
            "node_id",
            "occurrences",
            "reference",
            "rm_type_name",
            "terminology",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F1),
                            "node_id" => ::core::result::Result::Ok(__Field::__F2),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F3),
                            "terminology" => ::core::result::Result::Ok(__Field::__F4),
                            "code_list" => ::core::result::Result::Ok(__Field::__F5),
                            "reference" => ::core::result::Result::Ok(__Field::__F6),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_CODED_TEXT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::openehr_archetype_profile::c_coded_text::CCodedText;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_CODED_TEXT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_CODED_TEXT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("terminology"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("code_list"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("reference"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::aom14::openehr_archetype_profile::c_coded_text::CCodedText {
                        rm_type_name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
                        occurrences: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("occurrences"))?,
                        node_id: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
                        assumed_value: __s3.flatten(),
                        terminology: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("terminology"))?,
                        code_list: __s5.flatten(),
                        reference: __s6.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "C_CODED_TEXT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_4::aom14::archetype::constraint_model::c_complex_object::CComplexObject
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.attributes.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "C_COMPLEX_OBJECT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_COMPLEX_OBJECT")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "occurrences",
            &self.occurrences,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.attributes
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "attributes", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::constraint_model::c_complex_object::CComplexObject
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "assumed_value",
            "attributes",
            "node_id",
            "occurrences",
            "rm_type_name",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F1),
                            "node_id" => ::core::result::Result::Ok(__Field::__F2),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F3),
                            "attributes" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_COMPLEX_OBJECT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_4::aom14::archetype::constraint_model::c_complex_object::CComplexObject;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_COMPLEX_OBJECT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_COMPLEX_OBJECT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("attributes"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_complex_object::CComplexObject {
rm_type_name: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
occurrences: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("occurrences"))?,
node_id: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
assumed_value: __s3.flatten(),
attributes: __s4,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "C_COMPLEX_OBJECT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::archetype::primitive::c_date::CDate {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.day_validity.is_some() {
            __n += 1;
        }
        if self.month_validity.is_some() {
            __n += 1;
        }
        if self.range.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_DATE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_DATE")?;
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.day_validity {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "day_validity", __v)?;
        }
        if let Some(__v) = &self.month_validity {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "month_validity", __v)?;
        }
        if let Some(__v) = &self.range {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "range", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_4::aom14::archetype::primitive::c_date::CDate {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["assumed_value", "day_validity", "month_validity", "range"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F0),
                            "day_validity" => ::core::result::Result::Ok(__Field::__F1),
                            "month_validity" => ::core::result::Result::Ok(__Field::__F2),
                            "range" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v, "C_DATE", __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::primitive::c_date::CDate;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_DATE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_DATE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("day_validity"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("month_validity"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("range"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::aom14::archetype::primitive::c_date::CDate {
                        assumed_value: __s0.flatten(),
                        day_validity: __s1.flatten(),
                        month_validity: __s2.flatten(),
                        range: __s3.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "C_DATE", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::archetype::primitive::c_date_time::CDateTime {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.month_validity.is_some() {
            __n += 1;
        }
        if self.day_validity.is_some() {
            __n += 1;
        }
        if self.hour_validity.is_some() {
            __n += 1;
        }
        if self.minute_validity.is_some() {
            __n += 1;
        }
        if self.second_validity.is_some() {
            __n += 1;
        }
        if self.millisecond_validity.is_some() {
            __n += 1;
        }
        if self.timezone_validity.is_some() {
            __n += 1;
        }
        if self.range.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_DATE_TIME", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_DATE_TIME")?;
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.month_validity {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "month_validity", __v)?;
        }
        if let Some(__v) = &self.day_validity {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "day_validity", __v)?;
        }
        if let Some(__v) = &self.hour_validity {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "hour_validity", __v)?;
        }
        if let Some(__v) = &self.minute_validity {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "minute_validity", __v)?;
        }
        if let Some(__v) = &self.second_validity {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "second_validity", __v)?;
        }
        if let Some(__v) = &self.millisecond_validity {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "millisecond_validity", __v)?;
        }
        if let Some(__v) = &self.timezone_validity {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "timezone_validity", __v)?;
        }
        if let Some(__v) = &self.range {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "range", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::primitive::c_date_time::CDateTime
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "assumed_value",
            "day_validity",
            "hour_validity",
            "millisecond_validity",
            "minute_validity",
            "month_validity",
            "range",
            "second_validity",
            "timezone_validity",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F0),
                            "month_validity" => ::core::result::Result::Ok(__Field::__F1),
                            "day_validity" => ::core::result::Result::Ok(__Field::__F2),
                            "hour_validity" => ::core::result::Result::Ok(__Field::__F3),
                            "minute_validity" => ::core::result::Result::Ok(__Field::__F4),
                            "second_validity" => ::core::result::Result::Ok(__Field::__F5),
                            "millisecond_validity" => ::core::result::Result::Ok(__Field::__F6),
                            "timezone_validity" => ::core::result::Result::Ok(__Field::__F7),
                            "range" => ::core::result::Result::Ok(__Field::__F8),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_DATE_TIME",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::primitive::c_date_time::CDateTime;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_DATE_TIME` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_DATE_TIME"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("month_validity"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("day_validity"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("hour_validity"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("minute_validity"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("second_validity"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("millisecond_validity"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("timezone_validity"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("range"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::aom14::archetype::primitive::c_date_time::CDateTime {
                        assumed_value: __s0.flatten(),
                        month_validity: __s1.flatten(),
                        day_validity: __s2.flatten(),
                        hour_validity: __s3.flatten(),
                        minute_validity: __s4.flatten(),
                        second_validity: __s5.flatten(),
                        millisecond_validity: __s6.flatten(),
                        timezone_validity: __s7.flatten(),
                        range: __s8.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "C_DATE_TIME",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_4::aom14::archetype::constraint_model::c_defined_object::CDefinedObject
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_4::aom14::archetype::constraint_model::c_defined_object::CDefinedObject::CCodedText(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::c_defined_object::CDefinedObject::CComplexObject(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::c_defined_object::CDefinedObject::COrdinal(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::c_defined_object::CDefinedObject::CPrimitiveObject(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::c_defined_object::CDefinedObject::CQuantity(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::constraint_model::c_defined_object::CDefinedObject
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "C_CODED_TEXT",
            "C_COMPLEX_OBJECT",
            "C_ORDINAL",
            "C_PRIMITIVE_OBJECT",
            "C_QUANTITY",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_4::aom14::archetype::constraint_model::c_defined_object::CDefinedObject;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_DEFINED_OBJECT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"C_CODED_TEXT" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_defined_object::CDefinedObject::CCodedText(::serde::Deserialize::deserialize(__rest)?)),
"C_COMPLEX_OBJECT" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_defined_object::CDefinedObject::CComplexObject(::serde::Deserialize::deserialize(__rest)?)),
"C_ORDINAL" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_defined_object::CDefinedObject::COrdinal(::serde::Deserialize::deserialize(__rest)?)),
"C_PRIMITIVE_OBJECT" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_defined_object::CDefinedObject::CPrimitiveObject(::serde::Deserialize::deserialize(__rest)?)),
"C_QUANTITY" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_defined_object::CDefinedObject::CQuantity(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("C_DEFINED_OBJECT", __other, "C_CODED_TEXT, C_COMPLEX_OBJECT, C_ORDINAL, C_PRIMITIVE_OBJECT, C_QUANTITY")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "C_DEFINED_OBJECT",
                            &__other,
                            "C_CODED_TEXT, C_COMPLEX_OBJECT, C_ORDINAL, C_PRIMITIVE_OBJECT, C_QUANTITY",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "C_DEFINED_OBJECT",
                            "C_CODED_TEXT, C_COMPLEX_OBJECT, C_ORDINAL, C_PRIMITIVE_OBJECT, C_QUANTITY",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_4::aom14::archetype::constraint_model::c_domain_type::CDomainType
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_4::aom14::archetype::constraint_model::c_domain_type::CDomainType::CCodedText(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::c_domain_type::CDomainType::COrdinal(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::c_domain_type::CDomainType::CQuantity(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::constraint_model::c_domain_type::CDomainType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["C_CODED_TEXT", "C_ORDINAL", "C_QUANTITY"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_4::aom14::archetype::constraint_model::c_domain_type::CDomainType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_DOMAIN_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"C_CODED_TEXT" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_domain_type::CDomainType::CCodedText(::serde::Deserialize::deserialize(__rest)?)),
"C_ORDINAL" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_domain_type::CDomainType::COrdinal(::serde::Deserialize::deserialize(__rest)?)),
"C_QUANTITY" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_domain_type::CDomainType::CQuantity(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("C_DOMAIN_TYPE", __other, "C_CODED_TEXT, C_ORDINAL, C_QUANTITY")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "C_DOMAIN_TYPE",
                            &__other,
                            "C_CODED_TEXT, C_ORDINAL, C_QUANTITY",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "C_DOMAIN_TYPE",
                            "C_CODED_TEXT, C_ORDINAL, C_QUANTITY",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::archetype::primitive::c_duration::CDuration {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.years_allowed.is_some() {
            __n += 1;
        }
        if self.months_allowed.is_some() {
            __n += 1;
        }
        if self.weeks_allowed.is_some() {
            __n += 1;
        }
        if self.days_allowed.is_some() {
            __n += 1;
        }
        if self.hours_allowed.is_some() {
            __n += 1;
        }
        if self.minutes_allowed.is_some() {
            __n += 1;
        }
        if self.seconds_allowed.is_some() {
            __n += 1;
        }
        if self.fractional_seconds_allowed.is_some() {
            __n += 1;
        }
        if self.range.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_DURATION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_DURATION")?;
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.years_allowed {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "years_allowed", __v)?;
        }
        if let Some(__v) = &self.months_allowed {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "months_allowed", __v)?;
        }
        if let Some(__v) = &self.weeks_allowed {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "weeks_allowed", __v)?;
        }
        if let Some(__v) = &self.days_allowed {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "days_allowed", __v)?;
        }
        if let Some(__v) = &self.hours_allowed {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "hours_allowed", __v)?;
        }
        if let Some(__v) = &self.minutes_allowed {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "minutes_allowed", __v)?;
        }
        if let Some(__v) = &self.seconds_allowed {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "seconds_allowed", __v)?;
        }
        if let Some(__v) = &self.fractional_seconds_allowed {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "fractional_seconds_allowed",
                __v,
            )?;
        }
        if let Some(__v) = &self.range {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "range", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::primitive::c_duration::CDuration
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "assumed_value",
            "days_allowed",
            "fractional_seconds_allowed",
            "hours_allowed",
            "minutes_allowed",
            "months_allowed",
            "range",
            "seconds_allowed",
            "weeks_allowed",
            "years_allowed",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F0),
                            "years_allowed" => ::core::result::Result::Ok(__Field::__F1),
                            "months_allowed" => ::core::result::Result::Ok(__Field::__F2),
                            "weeks_allowed" => ::core::result::Result::Ok(__Field::__F3),
                            "days_allowed" => ::core::result::Result::Ok(__Field::__F4),
                            "hours_allowed" => ::core::result::Result::Ok(__Field::__F5),
                            "minutes_allowed" => ::core::result::Result::Ok(__Field::__F6),
                            "seconds_allowed" => ::core::result::Result::Ok(__Field::__F7),
                            "fractional_seconds_allowed" => {
                                ::core::result::Result::Ok(__Field::__F8)
                            }
                            "range" => ::core::result::Result::Ok(__Field::__F9),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_DURATION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::primitive::c_duration::CDuration;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_DURATION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_DURATION"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("years_allowed"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("months_allowed"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("weeks_allowed"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("days_allowed"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("hours_allowed"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("minutes_allowed"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("seconds_allowed"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "fractional_seconds_allowed",
                                    ),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("range"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::aom14::archetype::primitive::c_duration::CDuration {
                        assumed_value: __s0.flatten(),
                        years_allowed: __s1.flatten(),
                        months_allowed: __s2.flatten(),
                        weeks_allowed: __s3.flatten(),
                        days_allowed: __s4.flatten(),
                        hours_allowed: __s5.flatten(),
                        minutes_allowed: __s6.flatten(),
                        seconds_allowed: __s7.flatten(),
                        fractional_seconds_allowed: __s8.flatten(),
                        range: __s9.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "C_DURATION", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::archetype::primitive::c_integer::CInteger {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.list.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.range.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_INTEGER", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_INTEGER")?;
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.list
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "list", __v)?;
        }
        if let Some(__v) = &self.range {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "range", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::primitive::c_integer::CInteger
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["assumed_value", "list", "range"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F0),
                            "list" => ::core::result::Result::Ok(__Field::__F1),
                            "range" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_INTEGER",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::primitive::c_integer::CInteger;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_INTEGER` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<_> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_INTEGER"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("list"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("range"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::aom14::archetype::primitive::c_integer::CInteger {
                        assumed_value: __s0.flatten(),
                        list: __s1,
                        range: __s2.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "C_INTEGER", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_4::aom14::archetype::constraint_model::c_multiple_attribute::CMultipleAttribute
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.children.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "C_MULTIPLE_ATTRIBUTE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_MULTIPLE_ATTRIBUTE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_attribute_name",
            &self.rm_attribute_name,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "existence", &self.existence)?;
        if let Some(__v) = &self.children
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "children", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "cardinality",
            &self.cardinality,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::constraint_model::c_multiple_attribute::CMultipleAttribute
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["cardinality", "children", "existence", "rm_attribute_name"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_attribute_name" => ::core::result::Result::Ok(__Field::__F0),
                            "existence" => ::core::result::Result::Ok(__Field::__F1),
                            "children" => ::core::result::Result::Ok(__Field::__F2),
                            "cardinality" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_MULTIPLE_ATTRIBUTE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::constraint_model::c_multiple_attribute::CMultipleAttribute;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_MULTIPLE_ATTRIBUTE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<_> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_MULTIPLE_ATTRIBUTE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_attribute_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("existence"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("children"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("cardinality"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_multiple_attribute::CMultipleAttribute {
rm_attribute_name: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("rm_attribute_name"))?,
existence: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("existence"))?,
children: __s2,
cardinality: __s3.flatten().ok_or_else(|| ::serde::de::Error::missing_field("cardinality"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "C_MULTIPLE_ATTRIBUTE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::archetype::constraint_model::c_object::CObject {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_4::aom14::archetype::constraint_model::c_object::CObject::ArchetypeInternalRef(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::c_object::CObject::ArchetypeSlot(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::c_object::CObject::ConstraintRef(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::c_object::CObject::CCodedText(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::c_object::CObject::CComplexObject(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::c_object::CObject::COrdinal(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::c_object::CObject::CPrimitiveObject(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::c_object::CObject::CQuantity(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::constraint_model::c_object::CObject
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "ARCHETYPE_INTERNAL_REF",
            "ARCHETYPE_SLOT",
            "CONSTRAINT_REF",
            "C_CODED_TEXT",
            "C_COMPLEX_OBJECT",
            "C_ORDINAL",
            "C_PRIMITIVE_OBJECT",
            "C_QUANTITY",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::constraint_model::c_object::CObject;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_OBJECT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"ARCHETYPE_INTERNAL_REF" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_object::CObject::ArchetypeInternalRef(::serde::Deserialize::deserialize(__rest)?)),
"ARCHETYPE_SLOT" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_object::CObject::ArchetypeSlot(::serde::Deserialize::deserialize(__rest)?)),
"CONSTRAINT_REF" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_object::CObject::ConstraintRef(::serde::Deserialize::deserialize(__rest)?)),
"C_CODED_TEXT" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_object::CObject::CCodedText(::serde::Deserialize::deserialize(__rest)?)),
"C_COMPLEX_OBJECT" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_object::CObject::CComplexObject(::serde::Deserialize::deserialize(__rest)?)),
"C_ORDINAL" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_object::CObject::COrdinal(::serde::Deserialize::deserialize(__rest)?)),
"C_PRIMITIVE_OBJECT" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_object::CObject::CPrimitiveObject(::serde::Deserialize::deserialize(__rest)?)),
"C_QUANTITY" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_object::CObject::CQuantity(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("C_OBJECT", __other, "ARCHETYPE_INTERNAL_REF, ARCHETYPE_SLOT, CONSTRAINT_REF, C_CODED_TEXT, C_COMPLEX_OBJECT, C_ORDINAL, C_PRIMITIVE_OBJECT, C_QUANTITY")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "C_OBJECT",
                            &__other,
                            "ARCHETYPE_INTERNAL_REF, ARCHETYPE_SLOT, CONSTRAINT_REF, C_CODED_TEXT, C_COMPLEX_OBJECT, C_ORDINAL, C_PRIMITIVE_OBJECT, C_QUANTITY",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "C_OBJECT",
                            "ARCHETYPE_INTERNAL_REF, ARCHETYPE_SLOT, CONSTRAINT_REF, C_CODED_TEXT, C_COMPLEX_OBJECT, C_ORDINAL, C_PRIMITIVE_OBJECT, C_QUANTITY",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::openehr_archetype_profile::c_ordinal::COrdinal {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.list.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_ORDINAL", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_ORDINAL")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "occurrences",
            &self.occurrences,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.list
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "list", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::openehr_archetype_profile::c_ordinal::COrdinal
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "assumed_value",
            "list",
            "node_id",
            "occurrences",
            "rm_type_name",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F1),
                            "node_id" => ::core::result::Result::Ok(__Field::__F2),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F3),
                            "list" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_ORDINAL",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::openehr_archetype_profile::c_ordinal::COrdinal;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_ORDINAL` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_ORDINAL"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("list"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::aom14::openehr_archetype_profile::c_ordinal::COrdinal {
                        rm_type_name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
                        occurrences: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("occurrences"))?,
                        node_id: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
                        assumed_value: __s3.flatten(),
                        list: __s4,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "C_ORDINAL", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive::CBoolean(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive::CDate(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive::CDateTime(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive::CDuration(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive::CInteger(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive::CReal(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive::CString(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive::CTime(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "C_BOOLEAN",
            "C_DATE",
            "C_DATE_TIME",
            "C_DURATION",
            "C_INTEGER",
            "C_REAL",
            "C_STRING",
            "C_TIME",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_PRIMITIVE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"C_BOOLEAN" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive::CBoolean(::serde::Deserialize::deserialize(__rest)?)),
"C_DATE" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive::CDate(::serde::Deserialize::deserialize(__rest)?)),
"C_DATE_TIME" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive::CDateTime(::serde::Deserialize::deserialize(__rest)?)),
"C_DURATION" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive::CDuration(::serde::Deserialize::deserialize(__rest)?)),
"C_INTEGER" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive::CInteger(::serde::Deserialize::deserialize(__rest)?)),
"C_REAL" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive::CReal(::serde::Deserialize::deserialize(__rest)?)),
"C_STRING" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive::CString(::serde::Deserialize::deserialize(__rest)?)),
"C_TIME" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::primitive::c_primitive::CPrimitive::CTime(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("C_PRIMITIVE", __other, "C_BOOLEAN, C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_STRING, C_TIME")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "C_PRIMITIVE",
                            &__other,
                            "C_BOOLEAN, C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_STRING, C_TIME",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "C_PRIMITIVE",
                            "C_BOOLEAN, C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_STRING, C_TIME",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_4::aom14::archetype::constraint_model::c_primitive_object::CPrimitiveObject
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.assumed_value.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "C_PRIMITIVE_OBJECT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_PRIMITIVE_OBJECT")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "occurrences",
            &self.occurrences,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item", &self.item)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::constraint_model::c_primitive_object::CPrimitiveObject
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "assumed_value",
            "item",
            "node_id",
            "occurrences",
            "rm_type_name",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F1),
                            "node_id" => ::core::result::Result::Ok(__Field::__F2),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F3),
                            "item" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_PRIMITIVE_OBJECT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::constraint_model::c_primitive_object::CPrimitiveObject;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_PRIMITIVE_OBJECT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_PRIMITIVE_OBJECT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_primitive_object::CPrimitiveObject {
rm_type_name: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
occurrences: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("occurrences"))?,
node_id: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
assumed_value: __s3.flatten(),
item: __s4.flatten().ok_or_else(|| ::serde::de::Error::missing_field("item"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "C_PRIMITIVE_OBJECT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::openehr_archetype_profile::c_quantity::CQuantity {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.list.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_QUANTITY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_QUANTITY")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "occurrences",
            &self.occurrences,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "property", &self.property)?;
        if let Some(__v) = &self.list
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "list", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::openehr_archetype_profile::c_quantity::CQuantity
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "assumed_value",
            "list",
            "node_id",
            "occurrences",
            "property",
            "rm_type_name",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F1),
                            "node_id" => ::core::result::Result::Ok(__Field::__F2),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F3),
                            "property" => ::core::result::Result::Ok(__Field::__F4),
                            "list" => ::core::result::Result::Ok(__Field::__F5),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_QUANTITY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::openehr_archetype_profile::c_quantity::CQuantity;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_QUANTITY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_QUANTITY"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("property"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("list"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::aom14::openehr_archetype_profile::c_quantity::CQuantity {
                        rm_type_name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
                        occurrences: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("occurrences"))?,
                        node_id: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
                        assumed_value: __s3.flatten(),
                        property: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("property"))?,
                        list: __s5,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "C_QUANTITY", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_4::aom14::openehr_archetype_profile::c_quantity_item::CQuantityItem
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.units.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_QUANTITY_ITEM", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_QUANTITY_ITEM")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "magnitude", &self.magnitude)?;
        if let Some(__v) = &self.units {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "units", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::openehr_archetype_profile::c_quantity_item::CQuantityItem
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["magnitude", "units"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "magnitude" => ::core::result::Result::Ok(__Field::__F0),
                            "units" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_QUANTITY_ITEM",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_4::aom14::openehr_archetype_profile::c_quantity_item::CQuantityItem;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_QUANTITY_ITEM` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_QUANTITY_ITEM"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("magnitude"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("units"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::aom14::openehr_archetype_profile::c_quantity_item::CQuantityItem {
                        magnitude: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("magnitude"))?,
                        units: __s1.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "C_QUANTITY_ITEM",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::archetype::primitive::c_real::CReal {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.list.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.range.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_REAL", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_REAL")?;
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.list
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "list", __v)?;
        }
        if let Some(__v) = &self.range {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "range", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_4::aom14::archetype::primitive::c_real::CReal {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["assumed_value", "list", "range"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F0),
                            "list" => ::core::result::Result::Ok(__Field::__F1),
                            "range" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v, "C_REAL", __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::primitive::c_real::CReal;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_REAL` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<_> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_REAL"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("list"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("range"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::aom14::archetype::primitive::c_real::CReal {
                        assumed_value: __s0.flatten(),
                        list: __s1,
                        range: __s2.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "C_REAL", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_4::aom14::archetype::constraint_model::c_reference_object::CReferenceObject
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_4::aom14::archetype::constraint_model::c_reference_object::CReferenceObject::ArchetypeInternalRef(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::c_reference_object::CReferenceObject::ArchetypeSlot(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::constraint_model::c_reference_object::CReferenceObject::ConstraintRef(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::constraint_model::c_reference_object::CReferenceObject
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["ARCHETYPE_INTERNAL_REF", "ARCHETYPE_SLOT", "CONSTRAINT_REF"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::constraint_model::c_reference_object::CReferenceObject;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_REFERENCE_OBJECT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"ARCHETYPE_INTERNAL_REF" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_reference_object::CReferenceObject::ArchetypeInternalRef(::serde::Deserialize::deserialize(__rest)?)),
"ARCHETYPE_SLOT" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_reference_object::CReferenceObject::ArchetypeSlot(::serde::Deserialize::deserialize(__rest)?)),
"CONSTRAINT_REF" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_reference_object::CReferenceObject::ConstraintRef(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("C_REFERENCE_OBJECT", __other, "ARCHETYPE_INTERNAL_REF, ARCHETYPE_SLOT, CONSTRAINT_REF")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "C_REFERENCE_OBJECT",
                            &__other,
                            "ARCHETYPE_INTERNAL_REF, ARCHETYPE_SLOT, CONSTRAINT_REF",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "C_REFERENCE_OBJECT",
                            "ARCHETYPE_INTERNAL_REF, ARCHETYPE_SLOT, CONSTRAINT_REF",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_4::aom14::archetype::constraint_model::c_single_attribute::CSingleAttribute
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.children.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "C_SINGLE_ATTRIBUTE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_SINGLE_ATTRIBUTE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_attribute_name",
            &self.rm_attribute_name,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "existence", &self.existence)?;
        if let Some(__v) = &self.children
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "children", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::constraint_model::c_single_attribute::CSingleAttribute
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["children", "existence", "rm_attribute_name"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_attribute_name" => ::core::result::Result::Ok(__Field::__F0),
                            "existence" => ::core::result::Result::Ok(__Field::__F1),
                            "children" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_SINGLE_ATTRIBUTE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::constraint_model::c_single_attribute::CSingleAttribute;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_SINGLE_ATTRIBUTE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_SINGLE_ATTRIBUTE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_attribute_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("existence"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("children"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_4::aom14::archetype::constraint_model::c_single_attribute::CSingleAttribute {
rm_attribute_name: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("rm_attribute_name"))?,
existence: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("existence"))?,
children: __s2,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "C_SINGLE_ATTRIBUTE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::archetype::primitive::c_string::CString {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.pattern.is_some() {
            __n += 1;
        }
        if self.list.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_STRING", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_STRING")?;
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.pattern {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "pattern", __v)?;
        }
        if let Some(__v) = &self.list
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "list", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "list_open", &self.list_open)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::primitive::c_string::CString
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["assumed_value", "list", "list_open", "pattern"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F0),
                            "pattern" => ::core::result::Result::Ok(__Field::__F1),
                            "list" => ::core::result::Result::Ok(__Field::__F2),
                            "list_open" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v, "C_STRING", __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::primitive::c_string::CString;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_STRING` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<_> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_STRING"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("pattern"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("list"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("list_open"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::aom14::archetype::primitive::c_string::CString {
                        assumed_value: __s0.flatten(),
                        pattern: __s1.flatten(),
                        list: __s2,
                        list_open: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("list_open"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "C_STRING", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::archetype::primitive::c_time::CTime {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.minute_validity.is_some() {
            __n += 1;
        }
        if self.second_validity.is_some() {
            __n += 1;
        }
        if self.millisecond_validity.is_some() {
            __n += 1;
        }
        if self.timezone_validity.is_some() {
            __n += 1;
        }
        if self.range.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_TIME", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_TIME")?;
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.minute_validity {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "minute_validity", __v)?;
        }
        if let Some(__v) = &self.second_validity {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "second_validity", __v)?;
        }
        if let Some(__v) = &self.millisecond_validity {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "millisecond_validity", __v)?;
        }
        if let Some(__v) = &self.timezone_validity {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "timezone_validity", __v)?;
        }
        if let Some(__v) = &self.range {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "range", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_4::aom14::archetype::primitive::c_time::CTime {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "assumed_value",
            "millisecond_validity",
            "minute_validity",
            "range",
            "second_validity",
            "timezone_validity",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F0),
                            "minute_validity" => ::core::result::Result::Ok(__Field::__F1),
                            "second_validity" => ::core::result::Result::Ok(__Field::__F2),
                            "millisecond_validity" => ::core::result::Result::Ok(__Field::__F3),
                            "timezone_validity" => ::core::result::Result::Ok(__Field::__F4),
                            "range" => ::core::result::Result::Ok(__Field::__F5),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v, "C_TIME", __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::primitive::c_time::CTime;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_TIME` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_TIME"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("minute_validity"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("second_validity"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("millisecond_validity"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("timezone_validity"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("range"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::aom14::archetype::primitive::c_time::CTime {
                        assumed_value: __s0.flatten(),
                        minute_validity: __s1.flatten(),
                        second_validity: __s2.flatten(),
                        millisecond_validity: __s3.flatten(),
                        timezone_validity: __s4.flatten(),
                        range: __s5.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "C_TIME", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_4::aom14::archetype::assertion::expr_binary_operator::ExprBinaryOperator
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.precedence_overridden.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "EXPR_BINARY_OPERATOR", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EXPR_BINARY_OPERATOR")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        if let Some(__v) = &self.precedence_overridden {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "precedence_overridden",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "operator", &self.operator)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "left_operand",
            &self.left_operand,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "right_operand",
            &self.right_operand,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::assertion::expr_binary_operator::ExprBinaryOperator
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "left_operand",
            "operator",
            "precedence_overridden",
            "right_operand",
            "type",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "precedence_overridden" => ::core::result::Result::Ok(__Field::__F1),
                            "operator" => ::core::result::Result::Ok(__Field::__F2),
                            "left_operand" => ::core::result::Result::Ok(__Field::__F3),
                            "right_operand" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EXPR_BINARY_OPERATOR",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_4::aom14::archetype::assertion::expr_binary_operator::ExprBinaryOperator;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_BINARY_OPERATOR` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EXPR_BINARY_OPERATOR"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("precedence_overridden"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("operator"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("left_operand"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("right_operand"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_4::aom14::archetype::assertion::expr_binary_operator::ExprBinaryOperator {
r#type: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
precedence_overridden: __s1.flatten(),
operator: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("operator"))?,
left_operand: __s3.flatten().ok_or_else(|| ::serde::de::Error::missing_field("left_operand"))?,
right_operand: __s4.flatten().ok_or_else(|| ::serde::de::Error::missing_field("right_operand"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EXPR_BINARY_OPERATOR",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::archetype::assertion::expr_item::ExprItem {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_4::aom14::archetype::assertion::expr_item::ExprItem::ExprBinaryOperator(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_4::aom14::archetype::assertion::expr_item::ExprItem::ExprLeaf(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_4::aom14::archetype::assertion::expr_item::ExprItem::ExprUnaryOperator(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::assertion::expr_item::ExprItem
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["EXPR_BINARY_OPERATOR", "EXPR_LEAF", "EXPR_UNARY_OPERATOR"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::assertion::expr_item::ExprItem;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_ITEM` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"EXPR_BINARY_OPERATOR" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::assertion::expr_item::ExprItem::ExprBinaryOperator(::serde::Deserialize::deserialize(__rest)?)),
"EXPR_LEAF" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::assertion::expr_item::ExprItem::ExprLeaf(::serde::Deserialize::deserialize(__rest)?)),
"EXPR_UNARY_OPERATOR" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::assertion::expr_item::ExprItem::ExprUnaryOperator(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EXPR_ITEM", __other, "EXPR_BINARY_OPERATOR, EXPR_LEAF, EXPR_UNARY_OPERATOR")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EXPR_ITEM",
                            &__other,
                            "EXPR_BINARY_OPERATOR, EXPR_LEAF, EXPR_UNARY_OPERATOR",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EXPR_ITEM",
                            "EXPR_BINARY_OPERATOR, EXPR_LEAF, EXPR_UNARY_OPERATOR",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::archetype::assertion::expr_leaf::ExprLeaf {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "EXPR_LEAF", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EXPR_LEAF")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "reference_type",
            &self.reference_type,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item", &self.item)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::assertion::expr_leaf::ExprLeaf
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["item", "reference_type", "type"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "reference_type" => ::core::result::Result::Ok(__Field::__F1),
                            "item" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EXPR_LEAF",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::assertion::expr_leaf::ExprLeaf;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_LEAF` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EXPR_LEAF"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("reference_type"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::aom14::archetype::assertion::expr_leaf::ExprLeaf {
                        r#type: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        reference_type: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("reference_type"))?,
                        item: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("item"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "EXPR_LEAF", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::archetype::assertion::expr_operator::ExprOperator {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_4::aom14::archetype::assertion::expr_operator::ExprOperator::ExprBinaryOperator(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_4::aom14::archetype::assertion::expr_operator::ExprOperator::ExprUnaryOperator(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::assertion::expr_operator::ExprOperator
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["EXPR_BINARY_OPERATOR", "EXPR_UNARY_OPERATOR"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::archetype::assertion::expr_operator::ExprOperator;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_OPERATOR` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"EXPR_BINARY_OPERATOR" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::assertion::expr_operator::ExprOperator::ExprBinaryOperator(::serde::Deserialize::deserialize(__rest)?)),
"EXPR_UNARY_OPERATOR" => ::core::result::Result::Ok(crate::v1_4::aom14::archetype::assertion::expr_operator::ExprOperator::ExprUnaryOperator(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EXPR_OPERATOR", __other, "EXPR_BINARY_OPERATOR, EXPR_UNARY_OPERATOR")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EXPR_OPERATOR",
                            &__other,
                            "EXPR_BINARY_OPERATOR, EXPR_UNARY_OPERATOR",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EXPR_OPERATOR",
                            "EXPR_BINARY_OPERATOR, EXPR_UNARY_OPERATOR",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_4::aom14::archetype::assertion::expr_unary_operator::ExprUnaryOperator
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.precedence_overridden.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "EXPR_UNARY_OPERATOR", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EXPR_UNARY_OPERATOR")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        if let Some(__v) = &self.precedence_overridden {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "precedence_overridden",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "operator", &self.operator)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "operand", &self.operand)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::assertion::expr_unary_operator::ExprUnaryOperator
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["operand", "operator", "precedence_overridden", "type"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "precedence_overridden" => ::core::result::Result::Ok(__Field::__F1),
                            "operator" => ::core::result::Result::Ok(__Field::__F2),
                            "operand" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EXPR_UNARY_OPERATOR",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_4::aom14::archetype::assertion::expr_unary_operator::ExprUnaryOperator;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_UNARY_OPERATOR` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EXPR_UNARY_OPERATOR"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("precedence_overridden"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("operator"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("operand"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_4::aom14::archetype::assertion::expr_unary_operator::ExprUnaryOperator {
r#type: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
precedence_overridden: __s1.flatten(),
operator: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("operator"))?,
operand: __s3.flatten().ok_or_else(|| ::serde::de::Error::missing_field("operand"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EXPR_UNARY_OPERATOR",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::archetype::assertion::operator_kind::OperatorKind {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serializer::serialize_str(__serializer, self.as_str())
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::archetype::assertion::operator_kind::OperatorKind
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        struct __V;
        impl<'de> ::serde::de::Visitor<'de> for __V {
            type Value = crate::v1_4::aom14::archetype::assertion::operator_kind::OperatorKind;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("a `OperatorKind` token")
            }
            fn visit_str<__E: ::serde::de::Error>(
                self,
                __v: &str,
            ) -> ::core::result::Result<Self::Value, __E> {
                ::core::result::Result::Ok(crate::v1_4::aom14::archetype::assertion::operator_kind::OperatorKind::from_wire(__v))
            }
        }
        ::serde::Deserializer::deserialize_str(__deserializer, __V)
    }
}

impl ::serde::Serialize for crate::v1_4::aom14::openehr_archetype_profile::ordinal::Ordinal {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "ORDINAL", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "ORDINAL")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "symbol", &self.symbol)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "value", &self.value)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::aom14::openehr_archetype_profile::ordinal::Ordinal
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["symbol", "value"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "symbol" => ::core::result::Result::Ok(__Field::__F0),
                            "value" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v, "ORDINAL", __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::aom14::openehr_archetype_profile::ordinal::Ordinal;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ORDINAL` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("ORDINAL"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("symbol"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::aom14::openehr_archetype_profile::ordinal::Ordinal {
                        symbol: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("symbol"))?,
                        value: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("value"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "ORDINAL", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_4::resource::resource_description::ResourceDescription {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.title.is_some() {
            __n += 1;
        }
        if self.original_namespace.is_some() {
            __n += 1;
        }
        if self.original_publisher.is_some() {
            __n += 1;
        }
        if self
            .other_contributors
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.custodian_namespace.is_some() {
            __n += 1;
        }
        if self.custodian_organisation.is_some() {
            __n += 1;
        }
        if self.copyright.is_some() {
            __n += 1;
        }
        if self.licence.is_some() {
            __n += 1;
        }
        if self.ip_acknowledgements.is_some() {
            __n += 1;
        }
        if self.references.is_some() {
            __n += 1;
        }
        if self.resource_package_uri.is_some() {
            __n += 1;
        }
        if self.conversion_details.is_some() {
            __n += 1;
        }
        if self.details.is_some() {
            __n += 1;
        }
        if self.other_details.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "RESOURCE_DESCRIPTION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "RESOURCE_DESCRIPTION")?;
        if let Some(__v) = &self.title {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "title", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "original_author",
            &self.original_author,
        )?;
        if let Some(__v) = &self.original_namespace {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "original_namespace", __v)?;
        }
        if let Some(__v) = &self.original_publisher {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "original_publisher", __v)?;
        }
        if let Some(__v) = &self.other_contributors
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "other_contributors", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "lifecycle_state",
            &self.lifecycle_state,
        )?;
        if let Some(__v) = &self.custodian_namespace {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "custodian_namespace", __v)?;
        }
        if let Some(__v) = &self.custodian_organisation {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "custodian_organisation",
                __v,
            )?;
        }
        if let Some(__v) = &self.copyright {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "copyright", __v)?;
        }
        if let Some(__v) = &self.licence {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "licence", __v)?;
        }
        if let Some(__v) = &self.ip_acknowledgements {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "ip_acknowledgements", __v)?;
        }
        if let Some(__v) = &self.references {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "references", __v)?;
        }
        if let Some(__v) = &self.resource_package_uri {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "resource_package_uri", __v)?;
        }
        if let Some(__v) = &self.conversion_details {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "conversion_details", __v)?;
        }
        if let Some(__v) = &self.details {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "details", __v)?;
        }
        if let Some(__v) = &self.other_details {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "other_details", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_4::resource::resource_description::ResourceDescription
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "conversion_details",
            "copyright",
            "custodian_namespace",
            "custodian_organisation",
            "details",
            "ip_acknowledgements",
            "licence",
            "lifecycle_state",
            "original_author",
            "original_namespace",
            "original_publisher",
            "other_contributors",
            "other_details",
            "references",
            "resource_package_uri",
            "title",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
            __F14,
            __F15,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "title" => ::core::result::Result::Ok(__Field::__F0),
                            "original_author" => ::core::result::Result::Ok(__Field::__F1),
                            "original_namespace" => ::core::result::Result::Ok(__Field::__F2),
                            "original_publisher" => ::core::result::Result::Ok(__Field::__F3),
                            "other_contributors" => ::core::result::Result::Ok(__Field::__F4),
                            "lifecycle_state" => ::core::result::Result::Ok(__Field::__F5),
                            "custodian_namespace" => ::core::result::Result::Ok(__Field::__F6),
                            "custodian_organisation" => ::core::result::Result::Ok(__Field::__F7),
                            "copyright" => ::core::result::Result::Ok(__Field::__F8),
                            "licence" => ::core::result::Result::Ok(__Field::__F9),
                            "ip_acknowledgements" => ::core::result::Result::Ok(__Field::__F10),
                            "references" => ::core::result::Result::Ok(__Field::__F11),
                            "resource_package_uri" => ::core::result::Result::Ok(__Field::__F12),
                            "conversion_details" => ::core::result::Result::Ok(__Field::__F13),
                            "details" => ::core::result::Result::Ok(__Field::__F14),
                            "other_details" => ::core::result::Result::Ok(__Field::__F15),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "RESOURCE_DESCRIPTION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_4::resource::resource_description::ResourceDescription;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `RESOURCE_DESCRIPTION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<_> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s14: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s15: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("RESOURCE_DESCRIPTION"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("title"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("original_author"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("original_namespace"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("original_publisher"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("other_contributors"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("lifecycle_state"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("custodian_namespace"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("custodian_organisation"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("copyright"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("licence"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("ip_acknowledgements"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("references"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("resource_package_uri"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("conversion_details"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F14 => {
                            if __s14.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("details"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F15 => {
                            if __s15.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("other_details"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_4::resource::resource_description::ResourceDescription {
                        title: __s0.flatten(),
                        original_author: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("original_author"))?,
                        original_namespace: __s2.flatten(),
                        original_publisher: __s3.flatten(),
                        other_contributors: __s4,
                        lifecycle_state: __s5
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("lifecycle_state"))?,
                        custodian_namespace: __s6.flatten(),
                        custodian_organisation: __s7.flatten(),
                        copyright: __s8.flatten(),
                        licence: __s9.flatten(),
                        ip_acknowledgements: __s10.flatten(),
                        references: __s11.flatten(),
                        resource_package_uri: __s12.flatten(),
                        conversion_details: __s13.flatten(),
                        details: __s14.flatten(),
                        other_details: __s15.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "RESOURCE_DESCRIPTION",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitionsData
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "ADL_CODE_DEFINITIONS", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "ADL_CODE_DEFINITIONS")?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitionsData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[];
        enum __Field {
            __Type,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "ADL_CODE_DEFINITIONS",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitionsData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ADL_CODE_DEFINITIONS` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("ADL_CODE_DEFINITIONS"),
                            )?;
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitionsData {},
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "ADL_CODE_DEFINITIONS",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::ArchetypeSlot(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CAttribute(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CBoolean(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CComplexObject(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CComplexObjectProxy(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CDate(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CDateTime(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CDuration(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CInteger(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CReal(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CString(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CTerminologyCode(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CTime(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::AdlCodeDefinitions(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "ADL_CODE_DEFINITIONS",
            "ARCHETYPE_SLOT",
            "C_ARCHETYPE_ROOT",
            "C_ATTRIBUTE",
            "C_BOOLEAN",
            "C_COMPLEX_OBJECT",
            "C_COMPLEX_OBJECT_PROXY",
            "C_DATE",
            "C_DATE_TIME",
            "C_DURATION",
            "C_INTEGER",
            "C_REAL",
            "C_STRING",
            "C_TERMINOLOGY_CODE",
            "C_TIME",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ADL_CODE_DEFINITIONS` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"ADL_CODE_DEFINITIONS" => ::core::result::Result::Ok(crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::AdlCodeDefinitions(::serde::Deserialize::deserialize(__rest)?)),
"ARCHETYPE_SLOT" => ::core::result::Result::Ok(crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::ArchetypeSlot(::serde::Deserialize::deserialize(__rest)?)),
"C_ARCHETYPE_ROOT" => ::core::result::Result::Ok(crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CComplexObject(::serde::Deserialize::deserialize(__rest)?)),
"C_ATTRIBUTE" => ::core::result::Result::Ok(crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CAttribute(::serde::Deserialize::deserialize(__rest)?)),
"C_BOOLEAN" => ::core::result::Result::Ok(crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CBoolean(::serde::Deserialize::deserialize(__rest)?)),
"C_COMPLEX_OBJECT" => ::core::result::Result::Ok(crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CComplexObject(::serde::Deserialize::deserialize(__rest)?)),
"C_COMPLEX_OBJECT_PROXY" => ::core::result::Result::Ok(crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CComplexObjectProxy(::serde::Deserialize::deserialize(__rest)?)),
"C_DATE" => ::core::result::Result::Ok(crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CDate(::serde::Deserialize::deserialize(__rest)?)),
"C_DATE_TIME" => ::core::result::Result::Ok(crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CDateTime(::serde::Deserialize::deserialize(__rest)?)),
"C_DURATION" => ::core::result::Result::Ok(crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CDuration(::serde::Deserialize::deserialize(__rest)?)),
"C_INTEGER" => ::core::result::Result::Ok(crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CInteger(::serde::Deserialize::deserialize(__rest)?)),
"C_REAL" => ::core::result::Result::Ok(crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CReal(::serde::Deserialize::deserialize(__rest)?)),
"C_STRING" => ::core::result::Result::Ok(crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CString(::serde::Deserialize::deserialize(__rest)?)),
"C_TERMINOLOGY_CODE" => ::core::result::Result::Ok(crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CTerminologyCode(::serde::Deserialize::deserialize(__rest)?)),
"C_TIME" => ::core::result::Result::Ok(crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::CTime(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("ADL_CODE_DEFINITIONS", __other, "ADL_CODE_DEFINITIONS, ARCHETYPE_SLOT, C_ARCHETYPE_ROOT, C_ATTRIBUTE, C_BOOLEAN, C_COMPLEX_OBJECT, C_COMPLEX_OBJECT_PROXY, C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_STRING, C_TERMINOLOGY_CODE, C_TIME")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "ADL_CODE_DEFINITIONS",
                            &__other,
                            "ADL_CODE_DEFINITIONS, ARCHETYPE_SLOT, C_ARCHETYPE_ROOT, C_ATTRIBUTE, C_BOOLEAN, C_COMPLEX_OBJECT, C_COMPLEX_OBJECT_PROXY, C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_STRING, C_TERMINOLOGY_CODE, C_TIME",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::aom2::definitions::adl_code_definitions::AdlCodeDefinitions::AdlCodeDefinitions(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::profile::aom_profile::AomProfile {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.archetype_parent_class.is_some() {
            __n += 1;
        }
        if self.archetype_data_value_parent_class.is_some() {
            __n += 1;
        }
        if self.aom_rm_type_mappings.is_some() {
            __n += 1;
        }
        if self.archetype_visualise_descendants_of.is_some() {
            __n += 1;
        }
        if self.aom_rm_type_substitutions.is_some() {
            __n += 1;
        }
        if self.aom_lifecycle_mappings.is_some() {
            __n += 1;
        }
        if self.rm_primitive_type_equivalences.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "AOM_PROFILE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "AOM_PROFILE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "profile_name",
            &self.profile_name,
        )?;
        if let Some(__v) = &self.archetype_parent_class {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "archetype_parent_class",
                __v,
            )?;
        }
        if let Some(__v) = &self.archetype_data_value_parent_class {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "archetype_data_value_parent_class",
                __v,
            )?;
        }
        if let Some(__v) = &self.aom_rm_type_mappings {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "aom_rm_type_mappings", __v)?;
        }
        if let Some(__v) = &self.archetype_visualise_descendants_of {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "archetype_visualise_descendants_of",
                __v,
            )?;
        }
        if let Some(__v) = &self.aom_rm_type_substitutions {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "aom_rm_type_substitutions",
                __v,
            )?;
        }
        if let Some(__v) = &self.aom_lifecycle_mappings {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "aom_lifecycle_mappings",
                __v,
            )?;
        }
        if let Some(__v) = &self.rm_primitive_type_equivalences {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "rm_primitive_type_equivalences",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::aom2::profile::aom_profile::AomProfile {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "aom_lifecycle_mappings",
            "aom_rm_type_mappings",
            "aom_rm_type_substitutions",
            "archetype_data_value_parent_class",
            "archetype_parent_class",
            "archetype_visualise_descendants_of",
            "profile_name",
            "rm_primitive_type_equivalences",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "profile_name" => ::core::result::Result::Ok(__Field::__F0),
                            "archetype_parent_class" => ::core::result::Result::Ok(__Field::__F1),
                            "archetype_data_value_parent_class" => {
                                ::core::result::Result::Ok(__Field::__F2)
                            }
                            "aom_rm_type_mappings" => ::core::result::Result::Ok(__Field::__F3),
                            "archetype_visualise_descendants_of" => {
                                ::core::result::Result::Ok(__Field::__F4)
                            }
                            "aom_rm_type_substitutions" => {
                                ::core::result::Result::Ok(__Field::__F5)
                            }
                            "aom_lifecycle_mappings" => ::core::result::Result::Ok(__Field::__F6),
                            "rm_primitive_type_equivalences" => {
                                ::core::result::Result::Ok(__Field::__F7)
                            }
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "AOM_PROFILE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::profile::aom_profile::AomProfile;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `AOM_PROFILE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("AOM_PROFILE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("profile_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("archetype_parent_class"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "archetype_data_value_parent_class",
                                    ),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("aom_rm_type_mappings"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "archetype_visualise_descendants_of",
                                    ),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "aom_rm_type_substitutions",
                                    ),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("aom_lifecycle_mappings"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "rm_primitive_type_equivalences",
                                    ),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::aom2::profile::aom_profile::AomProfile {
                    profile_name: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("profile_name"))?,
                    archetype_parent_class: __s1.flatten(),
                    archetype_data_value_parent_class: __s2.flatten(),
                    aom_rm_type_mappings: __s3.flatten(),
                    archetype_visualise_descendants_of: __s4.flatten(),
                    aom_rm_type_substitutions: __s5.flatten(),
                    aom_lifecycle_mappings: __s6.flatten(),
                    rm_primitive_type_equivalences: __s7.flatten(),
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "AOM_PROFILE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::profile::aom_property_mapping::AomPropertyMapping {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "AOM_PROPERTY_MAPPING", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "AOM_PROPERTY_MAPPING")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "source_property_name",
            &self.source_property_name,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "target_property_name",
            &self.target_property_name,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::profile::aom_property_mapping::AomPropertyMapping
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["source_property_name", "target_property_name"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "source_property_name" => ::core::result::Result::Ok(__Field::__F0),
                            "target_property_name" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "AOM_PROPERTY_MAPPING",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::profile::aom_property_mapping::AomPropertyMapping;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `AOM_PROPERTY_MAPPING` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("AOM_PROPERTY_MAPPING"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("source_property_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("target_property_name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::profile::aom_property_mapping::AomPropertyMapping {
                        source_property_name: __s0.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("source_property_name")
                        })?,
                        target_property_name: __s1.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("target_property_name")
                        })?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "AOM_PROPERTY_MAPPING",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::profile::aom_type_mapping::AomTypeMapping {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.property_mappings.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "AOM_TYPE_MAPPING", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "AOM_TYPE_MAPPING")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "source_class_name",
            &self.source_class_name,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "target_class_name",
            &self.target_class_name,
        )?;
        if let Some(__v) = &self.property_mappings {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "property_mappings", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::profile::aom_type_mapping::AomTypeMapping
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "property_mappings",
            "source_class_name",
            "target_class_name",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "source_class_name" => ::core::result::Result::Ok(__Field::__F0),
                            "target_class_name" => ::core::result::Result::Ok(__Field::__F1),
                            "property_mappings" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "AOM_TYPE_MAPPING",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::profile::aom_type_mapping::AomTypeMapping;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `AOM_TYPE_MAPPING` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("AOM_TYPE_MAPPING"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("source_class_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("target_class_name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("property_mappings"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::profile::aom_type_mapping::AomTypeMapping {
                        source_class_name: __s0.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("source_class_name")
                        })?,
                        target_class_name: __s1.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("target_class_name")
                        })?,
                        property_mappings: __s2.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "AOM_TYPE_MAPPING",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::archetype::archetype::Archetype {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::aom2::archetype::archetype::Archetype::AuthoredArchetype(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::archetype::archetype::Archetype::TemplateOverlay(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::aom2::archetype::archetype::Archetype {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "AUTHORED_ARCHETYPE",
            "OPERATIONAL_TEMPLATE",
            "TEMPLATE",
            "TEMPLATE_OVERLAY",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::archetype::archetype::Archetype;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ARCHETYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"AUTHORED_ARCHETYPE" => ::core::result::Result::Ok(crate::v2_4::aom2::archetype::archetype::Archetype::AuthoredArchetype(::serde::Deserialize::deserialize(__rest)?)),
"OPERATIONAL_TEMPLATE" => ::core::result::Result::Ok(crate::v2_4::aom2::archetype::archetype::Archetype::AuthoredArchetype(::serde::Deserialize::deserialize(__rest)?)),
"TEMPLATE" => ::core::result::Result::Ok(crate::v2_4::aom2::archetype::archetype::Archetype::AuthoredArchetype(::serde::Deserialize::deserialize(__rest)?)),
"TEMPLATE_OVERLAY" => ::core::result::Result::Ok(crate::v2_4::aom2::archetype::archetype::Archetype::TemplateOverlay(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("ARCHETYPE", __other, "AUTHORED_ARCHETYPE, OPERATIONAL_TEMPLATE, TEMPLATE, TEMPLATE_OVERLAY")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "ARCHETYPE",
                            &__other,
                            "AUTHORED_ARCHETYPE, OPERATIONAL_TEMPLATE, TEMPLATE, TEMPLATE_OVERLAY",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "ARCHETYPE",
                            "AUTHORED_ARCHETYPE, OPERATIONAL_TEMPLATE, TEMPLATE, TEMPLATE_OVERLAY",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::ArchetypeSlot(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CAttribute(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CBoolean(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CComplexObject(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CComplexObjectProxy(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CDate(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CDateTime(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CDuration(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CInteger(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CReal(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CString(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CTerminologyCode(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CTime(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "ARCHETYPE_SLOT",
            "C_ARCHETYPE_ROOT",
            "C_ATTRIBUTE",
            "C_BOOLEAN",
            "C_COMPLEX_OBJECT",
            "C_COMPLEX_OBJECT_PROXY",
            "C_DATE",
            "C_DATE_TIME",
            "C_DURATION",
            "C_INTEGER",
            "C_REAL",
            "C_STRING",
            "C_TERMINOLOGY_CODE",
            "C_TIME",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ARCHETYPE_CONSTRAINT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"ARCHETYPE_SLOT" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::ArchetypeSlot(::serde::Deserialize::deserialize(__rest)?)),
"C_ARCHETYPE_ROOT" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CComplexObject(::serde::Deserialize::deserialize(__rest)?)),
"C_ATTRIBUTE" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CAttribute(::serde::Deserialize::deserialize(__rest)?)),
"C_BOOLEAN" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CBoolean(::serde::Deserialize::deserialize(__rest)?)),
"C_COMPLEX_OBJECT" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CComplexObject(::serde::Deserialize::deserialize(__rest)?)),
"C_COMPLEX_OBJECT_PROXY" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CComplexObjectProxy(::serde::Deserialize::deserialize(__rest)?)),
"C_DATE" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CDate(::serde::Deserialize::deserialize(__rest)?)),
"C_DATE_TIME" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CDateTime(::serde::Deserialize::deserialize(__rest)?)),
"C_DURATION" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CDuration(::serde::Deserialize::deserialize(__rest)?)),
"C_INTEGER" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CInteger(::serde::Deserialize::deserialize(__rest)?)),
"C_REAL" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CReal(::serde::Deserialize::deserialize(__rest)?)),
"C_STRING" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CString(::serde::Deserialize::deserialize(__rest)?)),
"C_TERMINOLOGY_CODE" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CTerminologyCode(::serde::Deserialize::deserialize(__rest)?)),
"C_TIME" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::archetype_constraint::ArchetypeConstraint::CTime(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("ARCHETYPE_CONSTRAINT", __other, "ARCHETYPE_SLOT, C_ARCHETYPE_ROOT, C_ATTRIBUTE, C_BOOLEAN, C_COMPLEX_OBJECT, C_COMPLEX_OBJECT_PROXY, C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_STRING, C_TERMINOLOGY_CODE, C_TIME")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "ARCHETYPE_CONSTRAINT",
                            &__other,
                            "ARCHETYPE_SLOT, C_ARCHETYPE_ROOT, C_ATTRIBUTE, C_BOOLEAN, C_COMPLEX_OBJECT, C_COMPLEX_OBJECT_PROXY, C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_STRING, C_TERMINOLOGY_CODE, C_TIME",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "ARCHETYPE_CONSTRAINT",
                            "ARCHETYPE_SLOT, C_ARCHETYPE_ROOT, C_ATTRIBUTE, C_BOOLEAN, C_COMPLEX_OBJECT, C_COMPLEX_OBJECT_PROXY, C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_STRING, C_TERMINOLOGY_CODE, C_TIME",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::archetype::archetype_hrid::ArchetypeHrid {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 8usize;
        if self.namespace.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "ARCHETYPE_HRID", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "ARCHETYPE_HRID")?;
        if let Some(__v) = &self.namespace {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "namespace", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_publisher",
            &self.rm_publisher,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_package", &self.rm_package)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_class", &self.rm_class)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "concept_id", &self.concept_id)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "release_version",
            &self.release_version,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "version_status",
            &self.version_status,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "build_count",
            &self.build_count,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::archetype::archetype_hrid::ArchetypeHrid
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "build_count",
            "concept_id",
            "namespace",
            "release_version",
            "rm_class",
            "rm_package",
            "rm_publisher",
            "version_status",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "namespace" => ::core::result::Result::Ok(__Field::__F0),
                            "rm_publisher" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_package" => ::core::result::Result::Ok(__Field::__F2),
                            "rm_class" => ::core::result::Result::Ok(__Field::__F3),
                            "concept_id" => ::core::result::Result::Ok(__Field::__F4),
                            "release_version" => ::core::result::Result::Ok(__Field::__F5),
                            "version_status" => ::core::result::Result::Ok(__Field::__F6),
                            "build_count" => ::core::result::Result::Ok(__Field::__F7),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "ARCHETYPE_HRID",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::archetype::archetype_hrid::ArchetypeHrid;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ARCHETYPE_HRID` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("ARCHETYPE_HRID"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("namespace"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_publisher"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_package"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_class"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("concept_id"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("release_version"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("version_status"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("build_count"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::archetype::archetype_hrid::ArchetypeHrid {
                        namespace: __s0.flatten(),
                        rm_publisher: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_publisher"))?,
                        rm_package: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_package"))?,
                        rm_class: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_class"))?,
                        concept_id: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("concept_id"))?,
                        release_version: __s5
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("release_version"))?,
                        version_status: __s6
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("version_status"))?,
                        build_count: __s7
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("build_count"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "ARCHETYPE_HRID",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::constraint_model::archetype_id_constraint::ArchetypeIdConstraint
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "ARCHETYPE_ID_CONSTRAINT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "ARCHETYPE_ID_CONSTRAINT",
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constraint", &self.constraint)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::archetype_id_constraint::ArchetypeIdConstraint
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["constraint"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "constraint" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "ARCHETYPE_ID_CONSTRAINT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::aom2::constraint_model::archetype_id_constraint::ArchetypeIdConstraint;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ARCHETYPE_ID_CONSTRAINT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "ARCHETYPE_ID_CONSTRAINT",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constraint"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::archetype_id_constraint::ArchetypeIdConstraint {
constraint: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("constraint"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "ARCHETYPE_ID_CONSTRAINT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::archetype_slot::ArchetypeSlot {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.parent.is_some() {
            __n += 1;
        }
        if self.soc_parent.is_some() {
            __n += 1;
        }
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self
            .alternative_ids
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.sibling_order.is_some() {
            __n += 1;
        }
        if self.includes.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.excludes.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "ARCHETYPE_SLOT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "ARCHETYPE_SLOT")?;
        if let Some(__v) = &self.parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent", __v)?;
        }
        if let Some(__v) = &self.soc_parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "soc_parent", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.alternative_ids
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "alternative_ids", __v)?;
        }
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.sibling_order {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "sibling_order", __v)?;
        }
        if let Some(__v) = &self.includes
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "includes", __v)?;
        }
        if let Some(__v) = &self.excludes
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "excludes", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_closed", &self.is_closed)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::archetype_slot::ArchetypeSlot
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "alternative_ids",
            "excludes",
            "includes",
            "is_closed",
            "is_deprecated",
            "node_id",
            "occurrences",
            "parent",
            "rm_type_name",
            "sibling_order",
            "soc_parent",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent" => ::core::result::Result::Ok(__Field::__F0),
                            "soc_parent" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F2),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F3),
                            "node_id" => ::core::result::Result::Ok(__Field::__F4),
                            "alternative_ids" => ::core::result::Result::Ok(__Field::__F5),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F6),
                            "sibling_order" => ::core::result::Result::Ok(__Field::__F7),
                            "includes" => ::core::result::Result::Ok(__Field::__F8),
                            "excludes" => ::core::result::Result::Ok(__Field::__F9),
                            "is_closed" => ::core::result::Result::Ok(__Field::__F10),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "ARCHETYPE_SLOT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::archetype_slot::ArchetypeSlot;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ARCHETYPE_SLOT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<_> = None;
                let mut __s9: ::core::option::Option<_> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("ARCHETYPE_SLOT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("soc_parent"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("alternative_ids"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("sibling_order"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("includes"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("excludes"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_closed"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::constraint_model::archetype_slot::ArchetypeSlot {
                        parent: __s0.flatten(),
                        soc_parent: __s1.flatten(),
                        rm_type_name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
                        occurrences: __s3.flatten(),
                        node_id: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
                        alternative_ids: __s5,
                        is_deprecated: __s6.flatten(),
                        sibling_order: __s7.flatten(),
                        includes: __s8,
                        excludes: __s9,
                        is_closed: __s10
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_closed"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "ARCHETYPE_SLOT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::terminology::archetype_term::ArchetypeTerm {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.other_items.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "ARCHETYPE_TERM", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "ARCHETYPE_TERM")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "code", &self.code)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "text", &self.text)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "description",
            &self.description,
        )?;
        if let Some(__v) = &self.other_items {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "other_items", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::terminology::archetype_term::ArchetypeTerm
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["code", "description", "other_items", "text"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "code" => ::core::result::Result::Ok(__Field::__F0),
                            "text" => ::core::result::Result::Ok(__Field::__F1),
                            "description" => ::core::result::Result::Ok(__Field::__F2),
                            "other_items" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "ARCHETYPE_TERM",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::terminology::archetype_term::ArchetypeTerm;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ARCHETYPE_TERM` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("ARCHETYPE_TERM"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("code"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("text"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("description"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("other_items"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::terminology::archetype_term::ArchetypeTerm {
                        code: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("code"))?,
                        text: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("text"))?,
                        description: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("description"))?,
                        other_items: __s3.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "ARCHETYPE_TERM",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::terminology::archetype_terminology::ArchetypeTerminology
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.term_bindings.is_some() {
            __n += 1;
        }
        if self.value_sets.is_some() {
            __n += 1;
        }
        if self.terminology_extracts.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "ARCHETYPE_TERMINOLOGY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "ARCHETYPE_TERMINOLOGY",
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_differential",
            &self.is_differential,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "original_language",
            &self.original_language,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "concept_code",
            &self.concept_code,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "term_definitions",
            &self.term_definitions,
        )?;
        if let Some(__v) = &self.term_bindings {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "term_bindings", __v)?;
        }
        if let Some(__v) = &self.value_sets {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "value_sets", __v)?;
        }
        if let Some(__v) = &self.terminology_extracts {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "terminology_extracts", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::terminology::archetype_terminology::ArchetypeTerminology
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "concept_code",
            "is_differential",
            "original_language",
            "term_bindings",
            "term_definitions",
            "terminology_extracts",
            "value_sets",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "is_differential" => ::core::result::Result::Ok(__Field::__F0),
                            "original_language" => ::core::result::Result::Ok(__Field::__F1),
                            "concept_code" => ::core::result::Result::Ok(__Field::__F2),
                            "term_definitions" => ::core::result::Result::Ok(__Field::__F3),
                            "term_bindings" => ::core::result::Result::Ok(__Field::__F4),
                            "value_sets" => ::core::result::Result::Ok(__Field::__F5),
                            "terminology_extracts" => ::core::result::Result::Ok(__Field::__F6),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "ARCHETYPE_TERMINOLOGY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::aom2::terminology::archetype_terminology::ArchetypeTerminology;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ARCHETYPE_TERMINOLOGY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "ARCHETYPE_TERMINOLOGY",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_differential"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("original_language"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("concept_code"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("term_definitions"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("term_bindings"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value_sets"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("terminology_extracts"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::terminology::archetype_terminology::ArchetypeTerminology {
                        is_differential: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_differential"))?,
                        original_language: __s1.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("original_language")
                        })?,
                        concept_code: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("concept_code"))?,
                        term_definitions: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("term_definitions"))?,
                        term_bindings: __s4.flatten(),
                        value_sets: __s5.flatten(),
                        terminology_extracts: __s6.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "ARCHETYPE_TERMINOLOGY",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::beom::core::assertion::Assertion {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.tag.is_some() {
            __n += 1;
        }
        if self.string_expression.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "ASSERTION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "ASSERTION")?;
        if let Some(__v) = &self.tag {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "tag", __v)?;
        }
        if let Some(__v) = &self.string_expression {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "string_expression", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "expression", &self.expression)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::beom::core::assertion::Assertion {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["expression", "string_expression", "tag"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "tag" => ::core::result::Result::Ok(__Field::__F0),
                            "string_expression" => ::core::result::Result::Ok(__Field::__F1),
                            "expression" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "ASSERTION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::beom::core::assertion::Assertion;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ASSERTION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("ASSERTION"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("tag"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("string_expression"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("expression"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::beom::core::assertion::Assertion {
                    tag: __s0.flatten(),
                    string_expression: __s1.flatten(),
                    expression: __s2
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("expression"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "ASSERTION", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::beom::core::assignment::Assignment {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "ASSIGNMENT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "ASSIGNMENT")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "target", &self.target)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "source", &self.source)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::beom::core::assignment::Assignment {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["source", "target"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "target" => ::core::result::Result::Ok(__Field::__F0),
                            "source" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "ASSIGNMENT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::beom::core::assignment::Assignment;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `ASSIGNMENT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("ASSIGNMENT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("target"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("source"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::beom::core::assignment::Assignment {
                    target: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("target"))?,
                    source: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("source"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "ASSIGNMENT", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::archetype::authored_archetype::AuthoredArchetypeData
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 10usize;
        if self.parent_archetype_id.is_some() {
            __n += 1;
        }
        if self.rules.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.rm_overlay.is_some() {
            __n += 1;
        }
        if self.uid.is_some() {
            __n += 1;
        }
        if self.description.is_some() {
            __n += 1;
        }
        if self.is_controlled.is_some() {
            __n += 1;
        }
        if self.annotations.is_some() {
            __n += 1;
        }
        if self.translations.is_some() {
            __n += 1;
        }
        if self.adl_version.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "AUTHORED_ARCHETYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "AUTHORED_ARCHETYPE")?;
        if let Some(__v) = &self.parent_archetype_id {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent_archetype_id", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "archetype_id",
            &self.archetype_id,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_differential",
            &self.is_differential,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", &self.definition)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "terminology",
            &self.terminology,
        )?;
        if let Some(__v) = &self.rules
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rules", __v)?;
        }
        if let Some(__v) = &self.rm_overlay {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_overlay", __v)?;
        }
        if let Some(__v) = &self.uid {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "uid", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "original_language",
            &self.original_language,
        )?;
        if let Some(__v) = &self.description {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "description", __v)?;
        }
        if let Some(__v) = &self.is_controlled {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_controlled", __v)?;
        }
        if let Some(__v) = &self.annotations {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "annotations", __v)?;
        }
        if let Some(__v) = &self.translations {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "translations", __v)?;
        }
        if let Some(__v) = &self.adl_version {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "adl_version", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "build_uid", &self.build_uid)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_release", &self.rm_release)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_generated",
            &self.is_generated,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "other_meta_data",
            &self.other_meta_data,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::archetype::authored_archetype::AuthoredArchetypeData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "adl_version",
            "annotations",
            "archetype_id",
            "build_uid",
            "definition",
            "description",
            "is_controlled",
            "is_differential",
            "is_generated",
            "original_language",
            "other_meta_data",
            "parent_archetype_id",
            "rm_overlay",
            "rm_release",
            "rules",
            "terminology",
            "translations",
            "uid",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
            __F14,
            __F15,
            __F16,
            __F17,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent_archetype_id" => ::core::result::Result::Ok(__Field::__F0),
                            "archetype_id" => ::core::result::Result::Ok(__Field::__F1),
                            "is_differential" => ::core::result::Result::Ok(__Field::__F2),
                            "definition" => ::core::result::Result::Ok(__Field::__F3),
                            "terminology" => ::core::result::Result::Ok(__Field::__F4),
                            "rules" => ::core::result::Result::Ok(__Field::__F5),
                            "rm_overlay" => ::core::result::Result::Ok(__Field::__F6),
                            "uid" => ::core::result::Result::Ok(__Field::__F7),
                            "original_language" => ::core::result::Result::Ok(__Field::__F8),
                            "description" => ::core::result::Result::Ok(__Field::__F9),
                            "is_controlled" => ::core::result::Result::Ok(__Field::__F10),
                            "annotations" => ::core::result::Result::Ok(__Field::__F11),
                            "translations" => ::core::result::Result::Ok(__Field::__F12),
                            "adl_version" => ::core::result::Result::Ok(__Field::__F13),
                            "build_uid" => ::core::result::Result::Ok(__Field::__F14),
                            "rm_release" => ::core::result::Result::Ok(__Field::__F15),
                            "is_generated" => ::core::result::Result::Ok(__Field::__F16),
                            "other_meta_data" => ::core::result::Result::Ok(__Field::__F17),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "AUTHORED_ARCHETYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::archetype::authored_archetype::AuthoredArchetypeData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `AUTHORED_ARCHETYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s14: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s15: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s16: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s17: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("AUTHORED_ARCHETYPE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent_archetype_id"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("archetype_id"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_differential"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("definition"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("terminology"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rules"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_overlay"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("uid"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("original_language"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("description"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_controlled"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("annotations"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("translations"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("adl_version"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F14 => {
                            if __s14.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("build_uid"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F15 => {
                            if __s15.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_release"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F16 => {
                            if __s16.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_generated"),
                                );
                            }
                            __s16 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F17 => {
                            if __s17.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("other_meta_data"),
                                );
                            }
                            __s17 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::archetype::authored_archetype::AuthoredArchetypeData {
                        parent_archetype_id: __s0.flatten(),
                        archetype_id: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("archetype_id"))?,
                        is_differential: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_differential"))?,
                        definition: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("definition"))?,
                        terminology: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("terminology"))?,
                        rules: __s5,
                        rm_overlay: __s6.flatten(),
                        uid: __s7.flatten(),
                        original_language: __s8.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("original_language")
                        })?,
                        description: __s9.flatten(),
                        is_controlled: __s10.flatten(),
                        annotations: __s11.flatten(),
                        translations: __s12.flatten(),
                        adl_version: __s13.flatten(),
                        build_uid: __s14
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("build_uid"))?,
                        rm_release: __s15
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_release"))?,
                        is_generated: __s16
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_generated"))?,
                        other_meta_data: __s17
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("other_meta_data"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "AUTHORED_ARCHETYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::archetype::authored_archetype::AuthoredArchetype {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::aom2::archetype::authored_archetype::AuthoredArchetype::OperationalTemplate(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::archetype::authored_archetype::AuthoredArchetype::Template(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::archetype::authored_archetype::AuthoredArchetype::AuthoredArchetype(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::archetype::authored_archetype::AuthoredArchetype
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["AUTHORED_ARCHETYPE", "OPERATIONAL_TEMPLATE", "TEMPLATE"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::archetype::authored_archetype::AuthoredArchetype;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `AUTHORED_ARCHETYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"AUTHORED_ARCHETYPE" => ::core::result::Result::Ok(crate::v2_4::aom2::archetype::authored_archetype::AuthoredArchetype::AuthoredArchetype(::serde::Deserialize::deserialize(__rest)?)),
"OPERATIONAL_TEMPLATE" => ::core::result::Result::Ok(crate::v2_4::aom2::archetype::authored_archetype::AuthoredArchetype::OperationalTemplate(::serde::Deserialize::deserialize(__rest)?)),
"TEMPLATE" => ::core::result::Result::Ok(crate::v2_4::aom2::archetype::authored_archetype::AuthoredArchetype::Template(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("AUTHORED_ARCHETYPE", __other, "AUTHORED_ARCHETYPE, OPERATIONAL_TEMPLATE, TEMPLATE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "AUTHORED_ARCHETYPE",
                            &__other,
                            "AUTHORED_ARCHETYPE, OPERATIONAL_TEMPLATE, TEMPLATE",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::aom2::archetype::authored_archetype::AuthoredArchetype::AuthoredArchetype(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::resource::authored_resource::AuthoredResource {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::resource::authored_resource::AuthoredResource::AuthoredArchetype(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::resource::authored_resource::AuthoredResource::PAuthoredArchetype(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::resource::authored_resource::AuthoredResource {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "AUTHORED_ARCHETYPE",
            "OPERATIONAL_TEMPLATE",
            "P_AUTHORED_ARCHETYPE",
            "P_OPERATIONAL_TEMPLATE",
            "P_TEMPLATE",
            "TEMPLATE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::resource::authored_resource::AuthoredResource;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `AUTHORED_RESOURCE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"AUTHORED_ARCHETYPE" => ::core::result::Result::Ok(crate::v2_4::resource::authored_resource::AuthoredResource::AuthoredArchetype(::serde::Deserialize::deserialize(__rest)?)),
"OPERATIONAL_TEMPLATE" => ::core::result::Result::Ok(crate::v2_4::resource::authored_resource::AuthoredResource::AuthoredArchetype(::serde::Deserialize::deserialize(__rest)?)),
"P_AUTHORED_ARCHETYPE" => ::core::result::Result::Ok(crate::v2_4::resource::authored_resource::AuthoredResource::PAuthoredArchetype(::serde::Deserialize::deserialize(__rest)?)),
"P_OPERATIONAL_TEMPLATE" => ::core::result::Result::Ok(crate::v2_4::resource::authored_resource::AuthoredResource::PAuthoredArchetype(::serde::Deserialize::deserialize(__rest)?)),
"P_TEMPLATE" => ::core::result::Result::Ok(crate::v2_4::resource::authored_resource::AuthoredResource::PAuthoredArchetype(::serde::Deserialize::deserialize(__rest)?)),
"TEMPLATE" => ::core::result::Result::Ok(crate::v2_4::resource::authored_resource::AuthoredResource::AuthoredArchetype(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("AUTHORED_RESOURCE", __other, "AUTHORED_ARCHETYPE, OPERATIONAL_TEMPLATE, P_AUTHORED_ARCHETYPE, P_OPERATIONAL_TEMPLATE, P_TEMPLATE, TEMPLATE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "AUTHORED_RESOURCE",
                            &__other,
                            "AUTHORED_ARCHETYPE, OPERATIONAL_TEMPLATE, P_AUTHORED_ARCHETYPE, P_OPERATIONAL_TEMPLATE, P_TEMPLATE, TEMPLATE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "AUTHORED_RESOURCE",
                            "AUTHORED_ARCHETYPE, OPERATIONAL_TEMPLATE, P_AUTHORED_ARCHETYPE, P_OPERATIONAL_TEMPLATE, P_TEMPLATE, TEMPLATE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::statement::bmm_assertion::BmmAssertion {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.tag.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_ASSERTION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_ASSERTION")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "expression", &self.expression)?;
        if let Some(__v) = &self.tag {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "tag", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::statement::bmm_assertion::BmmAssertion {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["expression", "tag"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "expression" => ::core::result::Result::Ok(__Field::__F0),
                            "tag" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_ASSERTION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::statement::bmm_assertion::BmmAssertion;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_ASSERTION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_ASSERTION"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("expression"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("tag"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::statement::bmm_assertion::BmmAssertion {
                        expression: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("expression"))?,
                        tag: __s1.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_ASSERTION",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::statement::bmm_assignment::BmmAssignment {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_ASSIGNMENT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_ASSIGNMENT")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "target", &self.target)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "source", &self.source)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::statement::bmm_assignment::BmmAssignment
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["source", "target"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "target" => ::core::result::Result::Ok(__Field::__F0),
                            "source" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_ASSIGNMENT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::statement::bmm_assignment::BmmAssignment;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_ASSIGNMENT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_ASSIGNMENT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("target"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("source"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::statement::bmm_assignment::BmmAssignment {
                        target: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("target"))?,
                        source: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_ASSIGNMENT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm3::core::literal_value::bmm_boolean_value::BmmBooleanValue
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.syntax.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_BOOLEAN_VALUE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_BOOLEAN_VALUE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "value_literal",
            &self.value_literal,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "value", &self.value)?;
        if let Some(__v) = &self.syntax {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "syntax", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::literal_value::bmm_boolean_value::BmmBooleanValue
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["syntax", "type", "value", "value_literal"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "value_literal" => ::core::result::Result::Ok(__Field::__F0),
                            "value" => ::core::result::Result::Ok(__Field::__F1),
                            "syntax" => ::core::result::Result::Ok(__Field::__F2),
                            "type" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_BOOLEAN_VALUE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::literal_value::bmm_boolean_value::BmmBooleanValue;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_BOOLEAN_VALUE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_BOOLEAN_VALUE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value_literal"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("syntax"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::literal_value::bmm_boolean_value::BmmBooleanValue {
                        value_literal: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("value_literal"))?,
                        value: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("value"))?,
                        syntax: __s2.flatten(),
                        r#type: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_BOOLEAN_VALUE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmSignature(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmStatusType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmTupleType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_FUNCTION_TYPE",
            "BMM_PROCEDURE_TYPE",
            "BMM_PROPERTY_TYPE",
            "BMM_ROUTINE_TYPE",
            "BMM_SIGNATURE",
            "BMM_STATUS_TYPE",
            "BMM_TUPLE_TYPE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_BUILTIN_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_FUNCTION_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROPERTY_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ROUTINE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIGNATURE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STATUS_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmStatusType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_TUPLE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmTupleType(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_BUILTIN_TYPE", __other, "BMM_FUNCTION_TYPE, BMM_PROCEDURE_TYPE, BMM_PROPERTY_TYPE, BMM_ROUTINE_TYPE, BMM_SIGNATURE, BMM_STATUS_TYPE, BMM_TUPLE_TYPE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_BUILTIN_TYPE",
                            &__other,
                            "BMM_FUNCTION_TYPE, BMM_PROCEDURE_TYPE, BMM_PROPERTY_TYPE, BMM_ROUTINE_TYPE, BMM_SIGNATURE, BMM_STATUS_TYPE, BMM_TUPLE_TYPE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_BUILTIN_TYPE",
                            "BMM_FUNCTION_TYPE, BMM_PROCEDURE_TYPE, BMM_PROPERTY_TYPE, BMM_ROUTINE_TYPE, BMM_SIGNATURE, BMM_STATUS_TYPE, BMM_TUPLE_TYPE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_class::BmmClass {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm::core::bmm_class::BmmClass::BmmGenericClass(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_class::BmmClass::BmmSimpleClass(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm::core::bmm_class::BmmClass {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_ENUMERATION",
            "BMM_ENUMERATION_INTEGER",
            "BMM_ENUMERATION_STRING",
            "BMM_GENERIC_CLASS",
            "BMM_SIMPLE_CLASS",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_class::BmmClass;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_CLASS` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
                            "BMM_ENUMERATION" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_class::BmmClass::BmmSimpleClass(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_class::BmmClass::BmmSimpleClass(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_class::BmmClass::BmmSimpleClass(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_GENERIC_CLASS" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_class::BmmClass::BmmGenericClass(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_SIMPLE_CLASS" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_class::BmmClass::BmmSimpleClass(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            __other => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unexpected_type(
                                    "BMM_CLASS",
                                    __other,
                                    "BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_GENERIC_CLASS, BMM_SIMPLE_CLASS",
                                ),
                            ),
                        }
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_CLASS",
                            &__other,
                            "BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_GENERIC_CLASS, BMM_SIMPLE_CLASS",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_CLASS",
                            "BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_GENERIC_CLASS, BMM_SIMPLE_CLASS",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_classifier::BmmClassifier {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm::core::bmm_classifier::BmmClassifier::BmmGenericParameter(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm::core::bmm_classifier::BmmClassifier {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_GENERIC_PARAMETER"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_classifier::BmmClassifier;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_CLASSIFIER` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_GENERIC_PARAMETER" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_classifier::BmmClassifier::BmmGenericParameter(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_CLASSIFIER", __other, "BMM_GENERIC_PARAMETER")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_CLASSIFIER",
                            &__other,
                            "BMM_GENERIC_PARAMETER",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_CLASSIFIER",
                            "BMM_GENERIC_PARAMETER",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::feature::bmm_constant::BmmConstant {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_nullable.is_some() {
            __n += 1;
        }
        if self.is_synthesised_generic.is_some() {
            __n += 1;
        }
        if self
            .feature_extensions
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_CONSTANT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_CONSTANT")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        if let Some(__v) = &self.is_synthesised_generic {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_synthesised_generic",
                __v,
            )?;
        }
        if let Some(__v) = &self.feature_extensions
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "feature_extensions", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "group", &self.group)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "generator", &self.generator)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::feature::bmm_constant::BmmConstant
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "documentation",
            "extensions",
            "feature_extensions",
            "generator",
            "group",
            "is_nullable",
            "is_synthesised_generic",
            "name",
            "type",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "type" => ::core::result::Result::Ok(__Field::__F3),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F4),
                            "is_synthesised_generic" => ::core::result::Result::Ok(__Field::__F5),
                            "feature_extensions" => ::core::result::Result::Ok(__Field::__F6),
                            "group" => ::core::result::Result::Ok(__Field::__F7),
                            "generator" => ::core::result::Result::Ok(__Field::__F8),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_CONSTANT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::feature::bmm_constant::BmmConstant;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_CONSTANT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<_> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_CONSTANT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_nullable"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_synthesised_generic"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("feature_extensions"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("group"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("generator"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::feature::bmm_constant::BmmConstant {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s1.flatten(),
                        extensions: __s2.flatten(),
                        r#type: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        is_nullable: __s4.flatten(),
                        is_synthesised_generic: __s5.flatten(),
                        feature_extensions: __s6,
                        group: __s7
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("group"))?,
                        generator: __s8
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("generator"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_CONSTANT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm::core::bmm_container_property::BmmContainerPropertyData
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_nullable.is_some() {
            __n += 1;
        }
        if self.is_synthesised_generic.is_some() {
            __n += 1;
        }
        if self
            .feature_extensions
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.is_im_runtime.is_some() {
            __n += 1;
        }
        if self.is_im_infrastructure.is_some() {
            __n += 1;
        }
        if self.is_composition.is_some() {
            __n += 1;
        }
        if self.cardinality.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_CONTAINER_PROPERTY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "BMM_CONTAINER_PROPERTY",
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        if let Some(__v) = &self.is_synthesised_generic {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_synthesised_generic",
                __v,
            )?;
        }
        if let Some(__v) = &self.feature_extensions
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "feature_extensions", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "group", &self.group)?;
        if let Some(__v) = &self.is_im_runtime {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_im_runtime", __v)?;
        }
        if let Some(__v) = &self.is_im_infrastructure {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_im_infrastructure", __v)?;
        }
        if let Some(__v) = &self.is_composition {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_composition", __v)?;
        }
        if let Some(__v) = &self.cardinality {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "cardinality", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm::core::bmm_container_property::BmmContainerPropertyData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "cardinality",
            "documentation",
            "extensions",
            "feature_extensions",
            "group",
            "is_composition",
            "is_im_infrastructure",
            "is_im_runtime",
            "is_nullable",
            "is_synthesised_generic",
            "name",
            "type",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "type" => ::core::result::Result::Ok(__Field::__F3),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F4),
                            "is_synthesised_generic" => ::core::result::Result::Ok(__Field::__F5),
                            "feature_extensions" => ::core::result::Result::Ok(__Field::__F6),
                            "group" => ::core::result::Result::Ok(__Field::__F7),
                            "is_im_runtime" => ::core::result::Result::Ok(__Field::__F8),
                            "is_im_infrastructure" => ::core::result::Result::Ok(__Field::__F9),
                            "is_composition" => ::core::result::Result::Ok(__Field::__F10),
                            "cardinality" => ::core::result::Result::Ok(__Field::__F11),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_CONTAINER_PROPERTY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_container_property::BmmContainerPropertyData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_CONTAINER_PROPERTY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<_> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "BMM_CONTAINER_PROPERTY",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_nullable"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_synthesised_generic"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("feature_extensions"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("group"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_im_runtime"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_im_infrastructure"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_composition"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("cardinality"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm::core::bmm_container_property::BmmContainerPropertyData {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s1.flatten(),
                        extensions: __s2.flatten(),
                        r#type: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        is_nullable: __s4.flatten(),
                        is_synthesised_generic: __s5.flatten(),
                        feature_extensions: __s6,
                        group: __s7
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("group"))?,
                        is_im_runtime: __s8.flatten(),
                        is_im_infrastructure: __s9.flatten(),
                        is_composition: __s10.flatten(),
                        cardinality: __s11.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_CONTAINER_PROPERTY",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_container_property::BmmContainerProperty {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm::core::bmm_container_property::BmmContainerProperty::BmmIndexedContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm::core::bmm_container_property::BmmContainerProperty::BmmContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm::core::bmm_container_property::BmmContainerProperty
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_CONTAINER_PROPERTY", "BMM_INDEXED_CONTAINER_PROPERTY"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_container_property::BmmContainerProperty;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_CONTAINER_PROPERTY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_container_property::BmmContainerProperty::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_container_property::BmmContainerProperty::BmmIndexedContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_CONTAINER_PROPERTY", __other, "BMM_CONTAINER_PROPERTY, BMM_INDEXED_CONTAINER_PROPERTY")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_CONTAINER_PROPERTY",
                            &__other,
                            "BMM_CONTAINER_PROPERTY, BMM_INDEXED_CONTAINER_PROPERTY",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_container_property::BmmContainerProperty::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_container_type::BmmContainerTypeData {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.is_ordered.is_some() {
            __n += 1;
        }
        if self.is_unique.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_CONTAINER_TYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_CONTAINER_TYPE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "container_class",
            &self.container_class,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_type", &self.item_type)?;
        if let Some(__v) = &self.is_ordered {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_ordered", __v)?;
        }
        if let Some(__v) = &self.is_unique {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_unique", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm::core::bmm_container_type::BmmContainerTypeData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["container_class", "is_ordered", "is_unique", "item_type"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "container_class" => ::core::result::Result::Ok(__Field::__F0),
                            "item_type" => ::core::result::Result::Ok(__Field::__F1),
                            "is_ordered" => ::core::result::Result::Ok(__Field::__F2),
                            "is_unique" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_CONTAINER_TYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_container_type::BmmContainerTypeData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_CONTAINER_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_CONTAINER_TYPE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("container_class"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_type"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_ordered"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_unique"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm::core::bmm_container_type::BmmContainerTypeData {
                        container_class: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("container_class"))?,
                        item_type: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("item_type"))?,
                        is_ordered: __s2.flatten(),
                        is_unique: __s3.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_CONTAINER_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_container_type::BmmContainerType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm::core::bmm_container_type::BmmContainerType::BmmIndexedContainerType(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm::core::bmm_container_type::BmmContainerType::BmmContainerType(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm::core::bmm_container_type::BmmContainerType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_CONTAINER_TYPE", "BMM_INDEXED_CONTAINER_TYPE"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_container_type::BmmContainerType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_CONTAINER_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_container_type::BmmContainerType::BmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_container_type::BmmContainerType::BmmIndexedContainerType(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_CONTAINER_TYPE", __other, "BMM_CONTAINER_TYPE, BMM_INDEXED_CONTAINER_TYPE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_CONTAINER_TYPE",
                            &__other,
                            "BMM_CONTAINER_TYPE, BMM_INDEXED_CONTAINER_TYPE",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_container_type::BmmContainerType::BmmContainerType(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::statement::bmm_declaration::BmmDeclaration {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_DECLARATION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_DECLARATION")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "result", &self.result)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::statement::bmm_declaration::BmmDeclaration
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["name", "result", "type"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "result" => ::core::result::Result::Ok(__Field::__F1),
                            "type" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_DECLARATION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::statement::bmm_declaration::BmmDeclaration;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_DECLARATION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_DECLARATION"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("result"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::statement::bmm_declaration::BmmDeclaration {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        result: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("result"))?,
                        r#type: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_DECLARATION",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_definitions::BmmDefinitionsData {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_DEFINITIONS", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_DEFINITIONS")?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm::core::bmm_definitions::BmmDefinitionsData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[];
        enum __Field {
            __Type,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_DEFINITIONS",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_definitions::BmmDefinitionsData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_DEFINITIONS` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_DEFINITIONS"),
                            )?;
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm::core::bmm_definitions::BmmDefinitionsData {},
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_DEFINITIONS",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_definitions::BmmDefinitions {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm::core::bmm_definitions::BmmDefinitions::ReferenceModelAccess(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_definitions::BmmDefinitions::SchemaDescriptor(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_definitions::BmmDefinitions::BmmDefinitions(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm::core::bmm_definitions::BmmDefinitions {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_DEFINITIONS",
            "P_BMM_SCHEMA_DESCRIPTOR",
            "REFERENCE_MODEL_ACCESS",
            "SCHEMA_DESCRIPTOR",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_definitions::BmmDefinitions;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_DEFINITIONS` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_DEFINITIONS" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_definitions::BmmDefinitions::BmmDefinitions(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SCHEMA_DESCRIPTOR" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_definitions::BmmDefinitions::SchemaDescriptor(::serde::Deserialize::deserialize(__rest)?)),
"REFERENCE_MODEL_ACCESS" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_definitions::BmmDefinitions::ReferenceModelAccess(::serde::Deserialize::deserialize(__rest)?)),
"SCHEMA_DESCRIPTOR" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_definitions::BmmDefinitions::SchemaDescriptor(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_DEFINITIONS", __other, "BMM_DEFINITIONS, P_BMM_SCHEMA_DESCRIPTOR, REFERENCE_MODEL_ACCESS, SCHEMA_DESCRIPTOR")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_DEFINITIONS",
                            &__other,
                            "BMM_DEFINITIONS, P_BMM_SCHEMA_DESCRIPTOR, REFERENCE_MODEL_ACCESS, SCHEMA_DESCRIPTOR",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(
                            crate::v2_4::bmm::core::bmm_definitions::BmmDefinitions::BmmDefinitions(
                                ::serde::Deserialize::deserialize(__rest)?,
                            ),
                        )
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::entity::bmm_effective_type::BmmEffectiveType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmGenericType(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmSignature(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmSimpleType(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmStatusType(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmTupleType(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::entity::bmm_effective_type::BmmEffectiveType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_FUNCTION_TYPE",
            "BMM_GENERIC_TYPE",
            "BMM_PROCEDURE_TYPE",
            "BMM_PROPERTY_TYPE",
            "BMM_ROUTINE_TYPE",
            "BMM_SIGNATURE",
            "BMM_SIMPLE_TYPE",
            "BMM_STATUS_TYPE",
            "BMM_TUPLE_TYPE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::entity::bmm_effective_type::BmmEffectiveType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_EFFECTIVE_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_FUNCTION_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROPERTY_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ROUTINE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIGNATURE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmSimpleType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STATUS_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmStatusType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_TUPLE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmTupleType(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_EFFECTIVE_TYPE", __other, "BMM_FUNCTION_TYPE, BMM_GENERIC_TYPE, BMM_PROCEDURE_TYPE, BMM_PROPERTY_TYPE, BMM_ROUTINE_TYPE, BMM_SIGNATURE, BMM_SIMPLE_TYPE, BMM_STATUS_TYPE, BMM_TUPLE_TYPE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_EFFECTIVE_TYPE",
                            &__other,
                            "BMM_FUNCTION_TYPE, BMM_GENERIC_TYPE, BMM_PROCEDURE_TYPE, BMM_PROPERTY_TYPE, BMM_ROUTINE_TYPE, BMM_SIGNATURE, BMM_SIMPLE_TYPE, BMM_STATUS_TYPE, BMM_TUPLE_TYPE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_EFFECTIVE_TYPE",
                            "BMM_FUNCTION_TYPE, BMM_GENERIC_TYPE, BMM_PROCEDURE_TYPE, BMM_PROPERTY_TYPE, BMM_ROUTINE_TYPE, BMM_SIGNATURE, BMM_SIMPLE_TYPE, BMM_STATUS_TYPE, BMM_TUPLE_TYPE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_enumeration::BmmEnumerationData {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self
            .feature_groups
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.features.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.ancestors.is_some() {
            __n += 1;
        }
        if self.properties.is_some() {
            __n += 1;
        }
        if self
            .immediate_descendants
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.static_properties.is_some() {
            __n += 1;
        }
        if self.functions.is_some() {
            __n += 1;
        }
        if self.procedures.is_some() {
            __n += 1;
        }
        if self.is_primitive.is_some() {
            __n += 1;
        }
        if self.is_abstract.is_some() {
            __n += 1;
        }
        if self.invariants.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.creators.is_some() {
            __n += 1;
        }
        if self.converters.is_some() {
            __n += 1;
        }
        if self.item_names.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.item_values.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_ENUMERATION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_ENUMERATION")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        if let Some(__v) = &self.feature_groups
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "feature_groups", __v)?;
        }
        if let Some(__v) = &self.features
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "features", __v)?;
        }
        if let Some(__v) = &self.ancestors {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "ancestors", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "package", &self.package)?;
        if let Some(__v) = &self.properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "properties", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "source_schema_id",
            &self.source_schema_id,
        )?;
        if let Some(__v) = &self.immediate_descendants
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "immediate_descendants",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_override",
            &self.is_override,
        )?;
        if let Some(__v) = &self.static_properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "static_properties", __v)?;
        }
        if let Some(__v) = &self.functions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "functions", __v)?;
        }
        if let Some(__v) = &self.procedures {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "procedures", __v)?;
        }
        if let Some(__v) = &self.is_primitive {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_primitive", __v)?;
        }
        if let Some(__v) = &self.is_abstract {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_abstract", __v)?;
        }
        if let Some(__v) = &self.invariants
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "invariants", __v)?;
        }
        if let Some(__v) = &self.creators {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "creators", __v)?;
        }
        if let Some(__v) = &self.converters {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "converters", __v)?;
        }
        if let Some(__v) = &self.item_names
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_names", __v)?;
        }
        if let Some(__v) = &self.item_values
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_values", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm::core::bmm_enumeration::BmmEnumerationData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "ancestors",
            "converters",
            "creators",
            "documentation",
            "extensions",
            "feature_groups",
            "features",
            "functions",
            "immediate_descendants",
            "invariants",
            "is_abstract",
            "is_override",
            "is_primitive",
            "item_names",
            "item_values",
            "name",
            "package",
            "procedures",
            "properties",
            "source_schema_id",
            "static_properties",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
            __F14,
            __F15,
            __F16,
            __F17,
            __F18,
            __F19,
            __F20,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "feature_groups" => ::core::result::Result::Ok(__Field::__F3),
                            "features" => ::core::result::Result::Ok(__Field::__F4),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F5),
                            "package" => ::core::result::Result::Ok(__Field::__F6),
                            "properties" => ::core::result::Result::Ok(__Field::__F7),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F8),
                            "immediate_descendants" => ::core::result::Result::Ok(__Field::__F9),
                            "is_override" => ::core::result::Result::Ok(__Field::__F10),
                            "static_properties" => ::core::result::Result::Ok(__Field::__F11),
                            "functions" => ::core::result::Result::Ok(__Field::__F12),
                            "procedures" => ::core::result::Result::Ok(__Field::__F13),
                            "is_primitive" => ::core::result::Result::Ok(__Field::__F14),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F15),
                            "invariants" => ::core::result::Result::Ok(__Field::__F16),
                            "creators" => ::core::result::Result::Ok(__Field::__F17),
                            "converters" => ::core::result::Result::Ok(__Field::__F18),
                            "item_names" => ::core::result::Result::Ok(__Field::__F19),
                            "item_values" => ::core::result::Result::Ok(__Field::__F20),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_ENUMERATION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_enumeration::BmmEnumerationData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_ENUMERATION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<_> = None;
                let mut __s4: ::core::option::Option<_> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<_> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s14: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s15: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s16: ::core::option::Option<_> = None;
                let mut __s17: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s18: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s19: ::core::option::Option<_> = None;
                let mut __s20: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_ENUMERATION"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("feature_groups"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("features"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("ancestors"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("package"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("properties"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("source_schema_id"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("immediate_descendants"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_override"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("static_properties"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("functions"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("procedures"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F14 => {
                            if __s14.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_primitive"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F15 => {
                            if __s15.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_abstract"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F16 => {
                            if __s16.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("invariants"),
                                );
                            }
                            __s16 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F17 => {
                            if __s17.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("creators"),
                                );
                            }
                            __s17 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F18 => {
                            if __s18.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("converters"),
                                );
                            }
                            __s18 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F19 => {
                            if __s19.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_names"),
                                );
                            }
                            __s19 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F20 => {
                            if __s20.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_values"),
                                );
                            }
                            __s20 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm::core::bmm_enumeration::BmmEnumerationData {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s1.flatten(),
                        extensions: __s2.flatten(),
                        feature_groups: __s3,
                        features: __s4,
                        ancestors: __s5.flatten(),
                        package: __s6
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("package"))?,
                        properties: __s7.flatten(),
                        source_schema_id: __s8
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                        immediate_descendants: __s9,
                        is_override: __s10
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_override"))?,
                        static_properties: __s11.flatten(),
                        functions: __s12.flatten(),
                        procedures: __s13.flatten(),
                        is_primitive: __s14.flatten(),
                        is_abstract: __s15.flatten(),
                        invariants: __s16,
                        creators: __s17.flatten(),
                        converters: __s18.flatten(),
                        item_names: __s19,
                        item_values: __s20,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_ENUMERATION",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_enumeration::BmmEnumeration {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm::core::bmm_enumeration::BmmEnumeration::BmmEnumerationInteger(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_enumeration::BmmEnumeration::BmmEnumerationString(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_enumeration::BmmEnumeration::BmmEnumeration(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm::core::bmm_enumeration::BmmEnumeration {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_ENUMERATION",
            "BMM_ENUMERATION_INTEGER",
            "BMM_ENUMERATION_STRING",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_enumeration::BmmEnumeration;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_ENUMERATION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_ENUMERATION" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_enumeration::BmmEnumeration::BmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_enumeration::BmmEnumeration::BmmEnumerationInteger(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_enumeration::BmmEnumeration::BmmEnumerationString(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_ENUMERATION", __other, "BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_ENUMERATION",
                            &__other,
                            "BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(
                            crate::v2_4::bmm::core::bmm_enumeration::BmmEnumeration::BmmEnumeration(
                                ::serde::Deserialize::deserialize(__rest)?,
                            ),
                        )
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_enumeration_integer::BmmEnumerationInteger {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self
            .feature_groups
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.features.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.ancestors.is_some() {
            __n += 1;
        }
        if self.properties.is_some() {
            __n += 1;
        }
        if self
            .immediate_descendants
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.static_properties.is_some() {
            __n += 1;
        }
        if self.functions.is_some() {
            __n += 1;
        }
        if self.procedures.is_some() {
            __n += 1;
        }
        if self.is_primitive.is_some() {
            __n += 1;
        }
        if self.is_abstract.is_some() {
            __n += 1;
        }
        if self.invariants.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.creators.is_some() {
            __n += 1;
        }
        if self.converters.is_some() {
            __n += 1;
        }
        if self.item_names.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.item_values.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_ENUMERATION_INTEGER", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "BMM_ENUMERATION_INTEGER",
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        if let Some(__v) = &self.feature_groups
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "feature_groups", __v)?;
        }
        if let Some(__v) = &self.features
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "features", __v)?;
        }
        if let Some(__v) = &self.ancestors {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "ancestors", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "package", &self.package)?;
        if let Some(__v) = &self.properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "properties", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "source_schema_id",
            &self.source_schema_id,
        )?;
        if let Some(__v) = &self.immediate_descendants
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "immediate_descendants",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_override",
            &self.is_override,
        )?;
        if let Some(__v) = &self.static_properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "static_properties", __v)?;
        }
        if let Some(__v) = &self.functions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "functions", __v)?;
        }
        if let Some(__v) = &self.procedures {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "procedures", __v)?;
        }
        if let Some(__v) = &self.is_primitive {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_primitive", __v)?;
        }
        if let Some(__v) = &self.is_abstract {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_abstract", __v)?;
        }
        if let Some(__v) = &self.invariants
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "invariants", __v)?;
        }
        if let Some(__v) = &self.creators {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "creators", __v)?;
        }
        if let Some(__v) = &self.converters {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "converters", __v)?;
        }
        if let Some(__v) = &self.item_names
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_names", __v)?;
        }
        if let Some(__v) = &self.item_values
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_values", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm::core::bmm_enumeration_integer::BmmEnumerationInteger
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "ancestors",
            "converters",
            "creators",
            "documentation",
            "extensions",
            "feature_groups",
            "features",
            "functions",
            "immediate_descendants",
            "invariants",
            "is_abstract",
            "is_override",
            "is_primitive",
            "item_names",
            "item_values",
            "name",
            "package",
            "procedures",
            "properties",
            "source_schema_id",
            "static_properties",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
            __F14,
            __F15,
            __F16,
            __F17,
            __F18,
            __F19,
            __F20,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "feature_groups" => ::core::result::Result::Ok(__Field::__F3),
                            "features" => ::core::result::Result::Ok(__Field::__F4),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F5),
                            "package" => ::core::result::Result::Ok(__Field::__F6),
                            "properties" => ::core::result::Result::Ok(__Field::__F7),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F8),
                            "immediate_descendants" => ::core::result::Result::Ok(__Field::__F9),
                            "is_override" => ::core::result::Result::Ok(__Field::__F10),
                            "static_properties" => ::core::result::Result::Ok(__Field::__F11),
                            "functions" => ::core::result::Result::Ok(__Field::__F12),
                            "procedures" => ::core::result::Result::Ok(__Field::__F13),
                            "is_primitive" => ::core::result::Result::Ok(__Field::__F14),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F15),
                            "invariants" => ::core::result::Result::Ok(__Field::__F16),
                            "creators" => ::core::result::Result::Ok(__Field::__F17),
                            "converters" => ::core::result::Result::Ok(__Field::__F18),
                            "item_names" => ::core::result::Result::Ok(__Field::__F19),
                            "item_values" => ::core::result::Result::Ok(__Field::__F20),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_ENUMERATION_INTEGER",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_enumeration_integer::BmmEnumerationInteger;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_ENUMERATION_INTEGER` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<_> = None;
                let mut __s4: ::core::option::Option<_> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<_> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s14: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s15: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s16: ::core::option::Option<_> = None;
                let mut __s17: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s18: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s19: ::core::option::Option<_> = None;
                let mut __s20: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "BMM_ENUMERATION_INTEGER",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("feature_groups"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("features"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("ancestors"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("package"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("properties"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("source_schema_id"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("immediate_descendants"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_override"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("static_properties"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("functions"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("procedures"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F14 => {
                            if __s14.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_primitive"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F15 => {
                            if __s15.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_abstract"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F16 => {
                            if __s16.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("invariants"),
                                );
                            }
                            __s16 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F17 => {
                            if __s17.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("creators"),
                                );
                            }
                            __s17 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F18 => {
                            if __s18.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("converters"),
                                );
                            }
                            __s18 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F19 => {
                            if __s19.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_names"),
                                );
                            }
                            __s19 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F20 => {
                            if __s20.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_values"),
                                );
                            }
                            __s20 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm::core::bmm_enumeration_integer::BmmEnumerationInteger {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s1.flatten(),
                        extensions: __s2.flatten(),
                        feature_groups: __s3,
                        features: __s4,
                        ancestors: __s5.flatten(),
                        package: __s6
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("package"))?,
                        properties: __s7.flatten(),
                        source_schema_id: __s8
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                        immediate_descendants: __s9,
                        is_override: __s10
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_override"))?,
                        static_properties: __s11.flatten(),
                        functions: __s12.flatten(),
                        procedures: __s13.flatten(),
                        is_primitive: __s14.flatten(),
                        is_abstract: __s15.flatten(),
                        invariants: __s16,
                        creators: __s17.flatten(),
                        converters: __s18.flatten(),
                        item_names: __s19,
                        item_values: __s20,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_ENUMERATION_INTEGER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_enumeration_string::BmmEnumerationString {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self
            .feature_groups
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.features.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.ancestors.is_some() {
            __n += 1;
        }
        if self.properties.is_some() {
            __n += 1;
        }
        if self
            .immediate_descendants
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.static_properties.is_some() {
            __n += 1;
        }
        if self.functions.is_some() {
            __n += 1;
        }
        if self.procedures.is_some() {
            __n += 1;
        }
        if self.is_primitive.is_some() {
            __n += 1;
        }
        if self.is_abstract.is_some() {
            __n += 1;
        }
        if self.invariants.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.creators.is_some() {
            __n += 1;
        }
        if self.converters.is_some() {
            __n += 1;
        }
        if self.item_names.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.item_values.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_ENUMERATION_STRING", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "BMM_ENUMERATION_STRING",
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        if let Some(__v) = &self.feature_groups
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "feature_groups", __v)?;
        }
        if let Some(__v) = &self.features
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "features", __v)?;
        }
        if let Some(__v) = &self.ancestors {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "ancestors", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "package", &self.package)?;
        if let Some(__v) = &self.properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "properties", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "source_schema_id",
            &self.source_schema_id,
        )?;
        if let Some(__v) = &self.immediate_descendants
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "immediate_descendants",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_override",
            &self.is_override,
        )?;
        if let Some(__v) = &self.static_properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "static_properties", __v)?;
        }
        if let Some(__v) = &self.functions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "functions", __v)?;
        }
        if let Some(__v) = &self.procedures {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "procedures", __v)?;
        }
        if let Some(__v) = &self.is_primitive {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_primitive", __v)?;
        }
        if let Some(__v) = &self.is_abstract {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_abstract", __v)?;
        }
        if let Some(__v) = &self.invariants
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "invariants", __v)?;
        }
        if let Some(__v) = &self.creators {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "creators", __v)?;
        }
        if let Some(__v) = &self.converters {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "converters", __v)?;
        }
        if let Some(__v) = &self.item_names
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_names", __v)?;
        }
        if let Some(__v) = &self.item_values
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_values", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm::core::bmm_enumeration_string::BmmEnumerationString
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "ancestors",
            "converters",
            "creators",
            "documentation",
            "extensions",
            "feature_groups",
            "features",
            "functions",
            "immediate_descendants",
            "invariants",
            "is_abstract",
            "is_override",
            "is_primitive",
            "item_names",
            "item_values",
            "name",
            "package",
            "procedures",
            "properties",
            "source_schema_id",
            "static_properties",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
            __F14,
            __F15,
            __F16,
            __F17,
            __F18,
            __F19,
            __F20,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "feature_groups" => ::core::result::Result::Ok(__Field::__F3),
                            "features" => ::core::result::Result::Ok(__Field::__F4),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F5),
                            "package" => ::core::result::Result::Ok(__Field::__F6),
                            "properties" => ::core::result::Result::Ok(__Field::__F7),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F8),
                            "immediate_descendants" => ::core::result::Result::Ok(__Field::__F9),
                            "is_override" => ::core::result::Result::Ok(__Field::__F10),
                            "static_properties" => ::core::result::Result::Ok(__Field::__F11),
                            "functions" => ::core::result::Result::Ok(__Field::__F12),
                            "procedures" => ::core::result::Result::Ok(__Field::__F13),
                            "is_primitive" => ::core::result::Result::Ok(__Field::__F14),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F15),
                            "invariants" => ::core::result::Result::Ok(__Field::__F16),
                            "creators" => ::core::result::Result::Ok(__Field::__F17),
                            "converters" => ::core::result::Result::Ok(__Field::__F18),
                            "item_names" => ::core::result::Result::Ok(__Field::__F19),
                            "item_values" => ::core::result::Result::Ok(__Field::__F20),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_ENUMERATION_STRING",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_enumeration_string::BmmEnumerationString;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_ENUMERATION_STRING` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<_> = None;
                let mut __s4: ::core::option::Option<_> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<_> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s14: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s15: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s16: ::core::option::Option<_> = None;
                let mut __s17: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s18: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s19: ::core::option::Option<_> = None;
                let mut __s20: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "BMM_ENUMERATION_STRING",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("feature_groups"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("features"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("ancestors"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("package"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("properties"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("source_schema_id"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("immediate_descendants"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_override"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("static_properties"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("functions"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("procedures"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F14 => {
                            if __s14.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_primitive"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F15 => {
                            if __s15.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_abstract"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F16 => {
                            if __s16.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("invariants"),
                                );
                            }
                            __s16 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F17 => {
                            if __s17.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("creators"),
                                );
                            }
                            __s17 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F18 => {
                            if __s18.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("converters"),
                                );
                            }
                            __s18 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F19 => {
                            if __s19.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_names"),
                                );
                            }
                            __s19 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F20 => {
                            if __s20.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_values"),
                                );
                            }
                            __s20 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm::core::bmm_enumeration_string::BmmEnumerationString {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s1.flatten(),
                        extensions: __s2.flatten(),
                        feature_groups: __s3,
                        features: __s4,
                        ancestors: __s5.flatten(),
                        package: __s6
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("package"))?,
                        properties: __s7.flatten(),
                        source_schema_id: __s8
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                        immediate_descendants: __s9,
                        is_override: __s10
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_override"))?,
                        static_properties: __s11.flatten(),
                        functions: __s12.flatten(),
                        procedures: __s13.flatten(),
                        is_primitive: __s14.flatten(),
                        is_abstract: __s15.flatten(),
                        invariants: __s16,
                        creators: __s17.flatten(),
                        converters: __s18.flatten(),
                        item_names: __s19,
                        item_values: __s20,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_ENUMERATION_STRING",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::feature::bmm_feature::BmmFeature {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::core::feature::bmm_feature::BmmFeature::BmmConstant(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::feature::bmm_feature::BmmFeature::BmmContainerProperty(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::bmm3::core::feature::bmm_feature::BmmFeature::BmmFunction(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::feature::bmm_feature::BmmFeature::BmmProcedure(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::feature::bmm_feature::BmmFeature::BmmSingleton(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::feature::bmm_feature::BmmFeature::BmmUnitaryProperty(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::core::feature::bmm_feature::BmmFeature {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_CONSTANT",
            "BMM_CONTAINER_PROPERTY",
            "BMM_FUNCTION",
            "BMM_INDEXED_CONTAINER_PROPERTY",
            "BMM_PROCEDURE",
            "BMM_SINGLETON",
            "BMM_UNITARY_PROPERTY",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::feature::bmm_feature::BmmFeature;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_FEATURE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_CONSTANT" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_feature::BmmFeature::BmmConstant(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_feature::BmmFeature::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_FUNCTION" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_feature::BmmFeature::BmmFunction(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_feature::BmmFeature::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_feature::BmmFeature::BmmProcedure(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SINGLETON" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_feature::BmmFeature::BmmSingleton(::serde::Deserialize::deserialize(__rest)?)),
"BMM_UNITARY_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_feature::BmmFeature::BmmUnitaryProperty(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_FEATURE", __other, "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_PROCEDURE, BMM_SINGLETON, BMM_UNITARY_PROPERTY")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_FEATURE",
                            &__other,
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_PROCEDURE, BMM_SINGLETON, BMM_UNITARY_PROPERTY",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_FEATURE",
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_PROCEDURE, BMM_SINGLETON, BMM_UNITARY_PROPERTY",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::feature::bmm_feature_group::BmmFeatureGroup {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.features.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.visibility.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_FEATURE_GROUP", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_FEATURE_GROUP")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "properties", &self.properties)?;
        if let Some(__v) = &self.features
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "features", __v)?;
        }
        if let Some(__v) = &self.visibility {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "visibility", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::feature::bmm_feature_group::BmmFeatureGroup
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["features", "name", "properties", "visibility"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "properties" => ::core::result::Result::Ok(__Field::__F1),
                            "features" => ::core::result::Result::Ok(__Field::__F2),
                            "visibility" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_FEATURE_GROUP",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::feature::bmm_feature_group::BmmFeatureGroup;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_FEATURE_GROUP` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<_> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_FEATURE_GROUP"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("properties"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("features"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("visibility"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::feature::bmm_feature_group::BmmFeatureGroup {
                        name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("feature")),
                        properties: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("properties"))?,
                        features: __s2,
                        visibility: __s3.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_FEATURE_GROUP",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmConstant(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmContainerProperty(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmFunction(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmLocal(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmParameter(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmProcedure(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmResult(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmSelf(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmSingleton(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmUnitaryProperty(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_CONSTANT",
            "BMM_CONTAINER_PROPERTY",
            "BMM_FUNCTION",
            "BMM_INDEXED_CONTAINER_PROPERTY",
            "BMM_LOCAL",
            "BMM_PARAMETER",
            "BMM_PROCEDURE",
            "BMM_RESULT",
            "BMM_SELF",
            "BMM_SINGLETON",
            "BMM_UNITARY_PROPERTY",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_FORMAL_ELEMENT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_CONSTANT" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmConstant(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_FUNCTION" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmFunction(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_LOCAL" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmLocal(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PARAMETER" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmProcedure(::serde::Deserialize::deserialize(__rest)?)),
"BMM_RESULT" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmResult(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SELF" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmSelf(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SINGLETON" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmSingleton(::serde::Deserialize::deserialize(__rest)?)),
"BMM_UNITARY_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::bmm_formal_element::BmmFormalElement::BmmUnitaryProperty(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_FORMAL_ELEMENT", __other, "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_PARAMETER, BMM_PROCEDURE, BMM_RESULT, BMM_SELF, BMM_SINGLETON, BMM_UNITARY_PROPERTY")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_FORMAL_ELEMENT",
                            &__other,
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_PARAMETER, BMM_PROCEDURE, BMM_RESULT, BMM_SELF, BMM_SINGLETON, BMM_UNITARY_PROPERTY",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_FORMAL_ELEMENT",
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_PARAMETER, BMM_PROCEDURE, BMM_RESULT, BMM_SELF, BMM_SINGLETON, BMM_UNITARY_PROPERTY",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::feature::bmm_function::BmmFunction {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_nullable.is_some() {
            __n += 1;
        }
        if self.is_synthesised_generic.is_some() {
            __n += 1;
        }
        if self
            .feature_extensions
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.parameters.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self
            .pre_conditions
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self
            .post_conditions
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.definition.is_some() {
            __n += 1;
        }
        if self.operator_definition.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_FUNCTION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_FUNCTION")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        if let Some(__v) = &self.is_synthesised_generic {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_synthesised_generic",
                __v,
            )?;
        }
        if let Some(__v) = &self.feature_extensions
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "feature_extensions", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "group", &self.group)?;
        if let Some(__v) = &self.parameters
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parameters", __v)?;
        }
        if let Some(__v) = &self.pre_conditions
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "pre_conditions", __v)?;
        }
        if let Some(__v) = &self.post_conditions
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "post_conditions", __v)?;
        }
        if let Some(__v) = &self.definition {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", __v)?;
        }
        if let Some(__v) = &self.operator_definition {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "operator_definition", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "result", &self.result)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::feature::bmm_function::BmmFunction
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "definition",
            "documentation",
            "extensions",
            "feature_extensions",
            "group",
            "is_nullable",
            "is_synthesised_generic",
            "name",
            "operator_definition",
            "parameters",
            "post_conditions",
            "pre_conditions",
            "result",
            "type",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "type" => ::core::result::Result::Ok(__Field::__F3),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F4),
                            "is_synthesised_generic" => ::core::result::Result::Ok(__Field::__F5),
                            "feature_extensions" => ::core::result::Result::Ok(__Field::__F6),
                            "group" => ::core::result::Result::Ok(__Field::__F7),
                            "parameters" => ::core::result::Result::Ok(__Field::__F8),
                            "pre_conditions" => ::core::result::Result::Ok(__Field::__F9),
                            "post_conditions" => ::core::result::Result::Ok(__Field::__F10),
                            "definition" => ::core::result::Result::Ok(__Field::__F11),
                            "operator_definition" => ::core::result::Result::Ok(__Field::__F12),
                            "result" => ::core::result::Result::Ok(__Field::__F13),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_FUNCTION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::feature::bmm_function::BmmFunction;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_FUNCTION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<_> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<_> = None;
                let mut __s9: ::core::option::Option<_> = None;
                let mut __s10: ::core::option::Option<_> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_FUNCTION"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_nullable"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_synthesised_generic"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("feature_extensions"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("group"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parameters"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("pre_conditions"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("post_conditions"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("definition"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("operator_definition"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("result"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::feature::bmm_function::BmmFunction {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s1.flatten(),
                        extensions: __s2.flatten(),
                        r#type: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        is_nullable: __s4.flatten(),
                        is_synthesised_generic: __s5.flatten(),
                        feature_extensions: __s6,
                        group: __s7
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("group"))?,
                        parameters: __s8,
                        pre_conditions: __s9,
                        post_conditions: __s10,
                        definition: __s11.flatten(),
                        operator_definition: __s12.flatten(),
                        result: __s13
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("result"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_FUNCTION",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::entity::bmm_function_type::BmmFunctionType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.argument_types.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_FUNCTION_TYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_FUNCTION_TYPE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "result_type",
            &self.result_type,
        )?;
        if let Some(__v) = &self.argument_types {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "argument_types", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::entity::bmm_function_type::BmmFunctionType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["argument_types", "result_type"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "result_type" => ::core::result::Result::Ok(__Field::__F0),
                            "argument_types" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_FUNCTION_TYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::entity::bmm_function_type::BmmFunctionType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_FUNCTION_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_FUNCTION_TYPE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("result_type"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("argument_types"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::entity::bmm_function_type::BmmFunctionType {
                        result_type: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("result_type"))?,
                        argument_types: __s1.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_FUNCTION_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_generic_class::BmmGenericClass {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 6usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self
            .feature_groups
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.features.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.ancestors.is_some() {
            __n += 1;
        }
        if self.properties.is_some() {
            __n += 1;
        }
        if self
            .immediate_descendants
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.static_properties.is_some() {
            __n += 1;
        }
        if self.functions.is_some() {
            __n += 1;
        }
        if self.procedures.is_some() {
            __n += 1;
        }
        if self.is_primitive.is_some() {
            __n += 1;
        }
        if self.is_abstract.is_some() {
            __n += 1;
        }
        if self.invariants.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.creators.is_some() {
            __n += 1;
        }
        if self.converters.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_GENERIC_CLASS", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_GENERIC_CLASS")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        if let Some(__v) = &self.feature_groups
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "feature_groups", __v)?;
        }
        if let Some(__v) = &self.features
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "features", __v)?;
        }
        if let Some(__v) = &self.ancestors {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "ancestors", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "package", &self.package)?;
        if let Some(__v) = &self.properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "properties", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "source_schema_id",
            &self.source_schema_id,
        )?;
        if let Some(__v) = &self.immediate_descendants
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "immediate_descendants",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_override",
            &self.is_override,
        )?;
        if let Some(__v) = &self.static_properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "static_properties", __v)?;
        }
        if let Some(__v) = &self.functions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "functions", __v)?;
        }
        if let Some(__v) = &self.procedures {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "procedures", __v)?;
        }
        if let Some(__v) = &self.is_primitive {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_primitive", __v)?;
        }
        if let Some(__v) = &self.is_abstract {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_abstract", __v)?;
        }
        if let Some(__v) = &self.invariants
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "invariants", __v)?;
        }
        if let Some(__v) = &self.creators {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "creators", __v)?;
        }
        if let Some(__v) = &self.converters {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "converters", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "generic_parameters",
            &self.generic_parameters,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm::core::bmm_generic_class::BmmGenericClass {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "ancestors",
            "converters",
            "creators",
            "documentation",
            "extensions",
            "feature_groups",
            "features",
            "functions",
            "generic_parameters",
            "immediate_descendants",
            "invariants",
            "is_abstract",
            "is_override",
            "is_primitive",
            "name",
            "package",
            "procedures",
            "properties",
            "source_schema_id",
            "static_properties",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
            __F14,
            __F15,
            __F16,
            __F17,
            __F18,
            __F19,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "feature_groups" => ::core::result::Result::Ok(__Field::__F3),
                            "features" => ::core::result::Result::Ok(__Field::__F4),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F5),
                            "package" => ::core::result::Result::Ok(__Field::__F6),
                            "properties" => ::core::result::Result::Ok(__Field::__F7),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F8),
                            "immediate_descendants" => ::core::result::Result::Ok(__Field::__F9),
                            "is_override" => ::core::result::Result::Ok(__Field::__F10),
                            "static_properties" => ::core::result::Result::Ok(__Field::__F11),
                            "functions" => ::core::result::Result::Ok(__Field::__F12),
                            "procedures" => ::core::result::Result::Ok(__Field::__F13),
                            "is_primitive" => ::core::result::Result::Ok(__Field::__F14),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F15),
                            "invariants" => ::core::result::Result::Ok(__Field::__F16),
                            "creators" => ::core::result::Result::Ok(__Field::__F17),
                            "converters" => ::core::result::Result::Ok(__Field::__F18),
                            "generic_parameters" => ::core::result::Result::Ok(__Field::__F19),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_GENERIC_CLASS",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_generic_class::BmmGenericClass;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_GENERIC_CLASS` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<_> = None;
                let mut __s4: ::core::option::Option<_> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<_> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s14: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s15: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s16: ::core::option::Option<_> = None;
                let mut __s17: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s18: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s19: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_GENERIC_CLASS"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("feature_groups"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("features"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("ancestors"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("package"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("properties"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("source_schema_id"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("immediate_descendants"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_override"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("static_properties"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("functions"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("procedures"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F14 => {
                            if __s14.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_primitive"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F15 => {
                            if __s15.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_abstract"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F16 => {
                            if __s16.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("invariants"),
                                );
                            }
                            __s16 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F17 => {
                            if __s17.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("creators"),
                                );
                            }
                            __s17 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F18 => {
                            if __s18.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("converters"),
                                );
                            }
                            __s18 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F19 => {
                            if __s19.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("generic_parameters"),
                                );
                            }
                            __s19 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm::core::bmm_generic_class::BmmGenericClass {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s1.flatten(),
                        extensions: __s2.flatten(),
                        feature_groups: __s3,
                        features: __s4,
                        ancestors: __s5.flatten(),
                        package: __s6
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("package"))?,
                        properties: __s7.flatten(),
                        source_schema_id: __s8
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                        immediate_descendants: __s9,
                        is_override: __s10
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_override"))?,
                        static_properties: __s11.flatten(),
                        functions: __s12.flatten(),
                        procedures: __s13.flatten(),
                        is_primitive: __s14.flatten(),
                        is_abstract: __s15.flatten(),
                        invariants: __s16,
                        creators: __s17.flatten(),
                        converters: __s18.flatten(),
                        generic_parameters: __s19.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("generic_parameters")
                        })?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_GENERIC_CLASS",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_generic_parameter::BmmGenericParameter {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.conforms_to_type.is_some() {
            __n += 1;
        }
        if self.inheritance_precursor.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_GENERIC_PARAMETER", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "BMM_GENERIC_PARAMETER",
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        if let Some(__v) = &self.conforms_to_type {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "conforms_to_type", __v)?;
        }
        if let Some(__v) = &self.inheritance_precursor {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "inheritance_precursor",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm::core::bmm_generic_parameter::BmmGenericParameter
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "conforms_to_type",
            "documentation",
            "extensions",
            "inheritance_precursor",
            "name",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "conforms_to_type" => ::core::result::Result::Ok(__Field::__F3),
                            "inheritance_precursor" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_GENERIC_PARAMETER",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_generic_parameter::BmmGenericParameter;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_GENERIC_PARAMETER` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "BMM_GENERIC_PARAMETER",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("conforms_to_type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("inheritance_precursor"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm::core::bmm_generic_parameter::BmmGenericParameter {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s1.flatten(),
                        extensions: __s2.flatten(),
                        conforms_to_type: __s3.flatten(),
                        inheritance_precursor: __s4.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_GENERIC_PARAMETER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_generic_type::BmmGenericType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.value_constraint.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_GENERIC_TYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_GENERIC_TYPE")?;
        if let Some(__v) = &self.value_constraint {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "value_constraint", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "base_class", &self.base_class)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "generic_parameters",
            &self.generic_parameters,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm::core::bmm_generic_type::BmmGenericType {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["base_class", "generic_parameters", "value_constraint"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "value_constraint" => ::core::result::Result::Ok(__Field::__F0),
                            "base_class" => ::core::result::Result::Ok(__Field::__F1),
                            "generic_parameters" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_GENERIC_TYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_generic_type::BmmGenericType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_GENERIC_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_GENERIC_TYPE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value_constraint"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("base_class"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("generic_parameters"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm::core::bmm_generic_type::BmmGenericType {
                        value_constraint: __s0.flatten(),
                        base_class: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("base_class"))?,
                        generic_parameters: __s2.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("generic_parameters")
                        })?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_GENERIC_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::feature::bmm_indexed_container_property::BmmIndexedContainerProperty {
fn serialize<__S: ::serde::Serializer>(&self, __serializer: __S) -> ::core::result::Result<__S::Ok, __S::Error> {
let mut __n = 4usize;
if self.documentation.is_some() { __n += 1; }
if self.extensions.is_some() { __n += 1; }
if self.is_nullable.is_some() { __n += 1; }
if self.is_synthesised_generic.is_some() { __n += 1; }
if self.feature_extensions.as_ref().is_some_and(|__v| !__v.is_empty()) { __n += 1; }
if self.is_im_runtime.is_some() { __n += 1; }
if self.is_im_infrastructure.is_some() { __n += 1; }
if self.is_composition.is_some() { __n += 1; }
if self.cardinality.is_some() { __n += 1; }
let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_INDEXED_CONTAINER_PROPERTY", __n)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_INDEXED_CONTAINER_PROPERTY")?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
if let Some(__v) = &self.documentation { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?; }
if let Some(__v) = &self.extensions { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?; }
::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
if let Some(__v) = &self.is_nullable { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?; }
if let Some(__v) = &self.is_synthesised_generic { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_synthesised_generic", __v)?; }
if let Some(__v) = &self.feature_extensions && !__v.is_empty() { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "feature_extensions", __v)?; }
::serde::ser::SerializeStruct::serialize_field(&mut __st, "group", &self.group)?;
if let Some(__v) = &self.is_im_runtime { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_im_runtime", __v)?; }
if let Some(__v) = &self.is_im_infrastructure { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_im_infrastructure", __v)?; }
if let Some(__v) = &self.is_composition { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_composition", __v)?; }
if let Some(__v) = &self.cardinality { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "cardinality", __v)?; }
::serde::ser::SerializeStruct::end(__st)
}
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::core::feature::bmm_indexed_container_property::BmmIndexedContainerProperty {
fn deserialize<__D: ::serde::Deserializer<'de>>(__deserializer: __D) -> ::core::result::Result<Self, __D::Error> {
const __FIELDS: &[&str] = &["cardinality", "documentation", "extensions", "feature_extensions", "group", "is_composition", "is_im_infrastructure", "is_im_runtime", "is_nullable", "is_synthesised_generic", "name", "type"];
enum __Field { __Type, __F0, __F1, __F2, __F3, __F4, __F5, __F6, __F7, __F8, __F9, __F10, __F11, }
impl<'de> ::serde::Deserialize<'de> for __Field {
fn deserialize<__D: ::serde::Deserializer<'de>>(__deserializer: __D) -> ::core::result::Result<Self, __D::Error> {
struct __KeyVisitor;
impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
type Value = __Field;
fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
__f.write_str("an object member name")
}
fn visit_str<__E: ::serde::de::Error>(self, __v: &str) -> ::core::result::Result<__Field, __E> {
match __v {
"_type" => ::core::result::Result::Ok(__Field::__Type),
"name" => ::core::result::Result::Ok(__Field::__F0),
"documentation" => ::core::result::Result::Ok(__Field::__F1),
"extensions" => ::core::result::Result::Ok(__Field::__F2),
"type" => ::core::result::Result::Ok(__Field::__F3),
"is_nullable" => ::core::result::Result::Ok(__Field::__F4),
"is_synthesised_generic" => ::core::result::Result::Ok(__Field::__F5),
"feature_extensions" => ::core::result::Result::Ok(__Field::__F6),
"group" => ::core::result::Result::Ok(__Field::__F7),
"is_im_runtime" => ::core::result::Result::Ok(__Field::__F8),
"is_im_infrastructure" => ::core::result::Result::Ok(__Field::__F9),
"is_composition" => ::core::result::Result::Ok(__Field::__F10),
"cardinality" => ::core::result::Result::Ok(__Field::__F11),
_ => ::core::result::Result::Err(::openehr_base::serde_support::unknown_field(__v, "BMM_INDEXED_CONTAINER_PROPERTY", __FIELDS)),
}
}
}
::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
}
}
struct __Visitor;
impl<'de> ::serde::de::Visitor<'de> for __Visitor {
type Value = crate::v2_4::bmm3::core::feature::bmm_indexed_container_property::BmmIndexedContainerProperty;
fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
__f.write_str("an openEHR `BMM_INDEXED_CONTAINER_PROPERTY` object")
}
fn visit_map<__A: ::serde::de::MapAccess<'de>>(self, mut __map: __A) -> ::core::result::Result<Self::Value, __A::Error> {
let mut __seen_type = false;
let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s6: ::core::option::Option<_> = None;
let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
 match __key {
__Field::__Type => {
if __seen_type { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("_type")); }
__seen_type = true;
::serde::de::MapAccess::next_value_seed(&mut __map, ::openehr_base::serde_support::ExpectedType("BMM_INDEXED_CONTAINER_PROPERTY"))?;
}
__Field::__F0 => {
if __s0.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("name")); }
__s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F1 => {
if __s1.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("documentation")); }
__s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F2 => {
if __s2.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("extensions")); }
__s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F3 => {
if __s3.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("type")); }
__s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F4 => {
if __s4.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("is_nullable")); }
__s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F5 => {
if __s5.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("is_synthesised_generic")); }
__s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F6 => {
if __s6.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("feature_extensions")); }
__s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F7 => {
if __s7.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("group")); }
__s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F8 => {
if __s8.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("is_im_runtime")); }
__s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F9 => {
if __s9.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("is_im_infrastructure")); }
__s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F10 => {
if __s10.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("is_composition")); }
__s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F11 => {
if __s11.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("cardinality")); }
__s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
}
}
::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_indexed_container_property::BmmIndexedContainerProperty {
name: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
documentation: __s1.flatten(),
extensions: __s2.flatten(),
r#type: __s3.flatten().ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
is_nullable: __s4.flatten(),
is_synthesised_generic: __s5.flatten(),
feature_extensions: __s6,
group: __s7.flatten().ok_or_else(|| ::serde::de::Error::missing_field("group"))?,
is_im_runtime: __s8.flatten(),
is_im_infrastructure: __s9.flatten(),
is_composition: __s10.flatten(),
cardinality: __s11.flatten(),
})
}
}
::serde::Deserializer::deserialize_struct(__deserializer, "BMM_INDEXED_CONTAINER_PROPERTY", __FIELDS, __Visitor)
}
}

impl ::serde::Serialize
    for crate::v2_4::bmm::core::bmm_indexed_container_type::BmmIndexedContainerType
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.is_ordered.is_some() {
            __n += 1;
        }
        if self.is_unique.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_INDEXED_CONTAINER_TYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "BMM_INDEXED_CONTAINER_TYPE",
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "container_class",
            &self.container_class,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_type", &self.item_type)?;
        if let Some(__v) = &self.is_ordered {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_ordered", __v)?;
        }
        if let Some(__v) = &self.is_unique {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_unique", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "index_type", &self.index_type)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm::core::bmm_indexed_container_type::BmmIndexedContainerType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "container_class",
            "index_type",
            "is_ordered",
            "is_unique",
            "item_type",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "container_class" => ::core::result::Result::Ok(__Field::__F0),
                            "item_type" => ::core::result::Result::Ok(__Field::__F1),
                            "is_ordered" => ::core::result::Result::Ok(__Field::__F2),
                            "is_unique" => ::core::result::Result::Ok(__Field::__F3),
                            "index_type" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_INDEXED_CONTAINER_TYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm::core::bmm_indexed_container_type::BmmIndexedContainerType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_INDEXED_CONTAINER_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "BMM_INDEXED_CONTAINER_TYPE",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("container_class"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_type"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_ordered"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_unique"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("index_type"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm::core::bmm_indexed_container_type::BmmIndexedContainerType {
                        container_class: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("container_class"))?,
                        item_type: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("item_type"))?,
                        is_ordered: __s2.flatten(),
                        is_unique: __s3.flatten(),
                        index_type: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("index_type"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_INDEXED_CONTAINER_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature::BmmConstant(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature::BmmContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature::BmmSingleton(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature::BmmUnitaryProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_CONSTANT",
            "BMM_CONTAINER_PROPERTY",
            "BMM_INDEXED_CONTAINER_PROPERTY",
            "BMM_SINGLETON",
            "BMM_UNITARY_PROPERTY",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_INSTANTIABLE_FEATURE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_CONSTANT" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature::BmmConstant(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SINGLETON" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature::BmmSingleton(::serde::Deserialize::deserialize(__rest)?)),
"BMM_UNITARY_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature::BmmUnitaryProperty(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_INSTANTIABLE_FEATURE", __other, "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_INDEXED_CONTAINER_PROPERTY, BMM_SINGLETON, BMM_UNITARY_PROPERTY")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_INSTANTIABLE_FEATURE",
                            &__other,
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_INDEXED_CONTAINER_PROPERTY, BMM_SINGLETON, BMM_UNITARY_PROPERTY",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_INSTANTIABLE_FEATURE",
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_INDEXED_CONTAINER_PROPERTY, BMM_SINGLETON, BMM_UNITARY_PROPERTY",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm3::core::literal_value::bmm_integer_value::BmmIntegerValue
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.syntax.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_INTEGER_VALUE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_INTEGER_VALUE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "value_literal",
            &self.value_literal,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "value", &self.value)?;
        if let Some(__v) = &self.syntax {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "syntax", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::literal_value::bmm_integer_value::BmmIntegerValue
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["syntax", "type", "value", "value_literal"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "value_literal" => ::core::result::Result::Ok(__Field::__F0),
                            "value" => ::core::result::Result::Ok(__Field::__F1),
                            "syntax" => ::core::result::Result::Ok(__Field::__F2),
                            "type" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_INTEGER_VALUE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::literal_value::bmm_integer_value::BmmIntegerValue;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_INTEGER_VALUE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_INTEGER_VALUE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value_literal"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("syntax"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::literal_value::bmm_integer_value::BmmIntegerValue {
                        value_literal: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("value_literal"))?,
                        value: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("value"))?,
                        syntax: __s2.flatten(),
                        r#type: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_INTEGER_VALUE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmContainerValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmIndexedContainerValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmIntervalValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmPrimitiveValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_BOOLEAN_VALUE",
            "BMM_CONTAINER_VALUE",
            "BMM_INDEXED_CONTAINER_VALUE",
            "BMM_INTEGER_VALUE",
            "BMM_INTERVAL_VALUE",
            "BMM_PRIMITIVE_VALUE",
            "BMM_STRING_VALUE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_LITERAL_VALUE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_BOOLEAN_VALUE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_VALUE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmContainerValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_VALUE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmIndexedContainerValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INTEGER_VALUE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INTERVAL_VALUE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmIntervalValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PRIMITIVE_VALUE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STRING_VALUE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_LITERAL_VALUE", __other, "BMM_BOOLEAN_VALUE, BMM_CONTAINER_VALUE, BMM_INDEXED_CONTAINER_VALUE, BMM_INTEGER_VALUE, BMM_INTERVAL_VALUE, BMM_PRIMITIVE_VALUE, BMM_STRING_VALUE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_LITERAL_VALUE",
                            &__other,
                            "BMM_BOOLEAN_VALUE, BMM_CONTAINER_VALUE, BMM_INDEXED_CONTAINER_VALUE, BMM_INTEGER_VALUE, BMM_INTERVAL_VALUE, BMM_PRIMITIVE_VALUE, BMM_STRING_VALUE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_LITERAL_VALUE",
                            "BMM_BOOLEAN_VALUE, BMM_CONTAINER_VALUE, BMM_INDEXED_CONTAINER_VALUE, BMM_INTEGER_VALUE, BMM_INTERVAL_VALUE, BMM_PRIMITIVE_VALUE, BMM_STRING_VALUE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::feature::bmm_local::BmmLocal {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_nullable.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_LOCAL", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_LOCAL")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::core::feature::bmm_local::BmmLocal {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["documentation", "extensions", "is_nullable", "name", "type"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "type" => ::core::result::Result::Ok(__Field::__F3),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_LOCAL",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::feature::bmm_local::BmmLocal;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_LOCAL` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_LOCAL"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_nullable"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_local::BmmLocal {
                    name: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                    documentation: __s1.flatten(),
                    extensions: __s2.flatten(),
                    r#type: __s3
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                    is_nullable: __s4.flatten(),
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "BMM_LOCAL", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::feature::bmm_local_routine::BmmLocalRoutine {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.locals.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_LOCAL_ROUTINE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_LOCAL_ROUTINE")?;
        if let Some(__v) = &self.locals
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "locals", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "body", &self.body)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::feature::bmm_local_routine::BmmLocalRoutine
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["body", "locals"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "locals" => ::core::result::Result::Ok(__Field::__F0),
                            "body" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_LOCAL_ROUTINE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::feature::bmm_local_routine::BmmLocalRoutine;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_LOCAL_ROUTINE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<_> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_LOCAL_ROUTINE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("locals"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("body"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::feature::bmm_local_routine::BmmLocalRoutine {
                        locals: __s0,
                        body: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("body"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_LOCAL_ROUTINE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_model::BmmModel {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.packages.is_some() {
            __n += 1;
        }
        if self.class_definitions.is_some() {
            __n += 1;
        }
        if self.used_models.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.modules.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_MODEL", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_MODEL")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        if let Some(__v) = &self.packages {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "packages", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_publisher",
            &self.rm_publisher,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_release", &self.rm_release)?;
        if let Some(__v) = &self.class_definitions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "class_definitions", __v)?;
        }
        if let Some(__v) = &self.used_models
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "used_models", __v)?;
        }
        if let Some(__v) = &self.modules {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "modules", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm::core::bmm_model::BmmModel {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "class_definitions",
            "documentation",
            "extensions",
            "modules",
            "name",
            "packages",
            "rm_publisher",
            "rm_release",
            "used_models",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "packages" => ::core::result::Result::Ok(__Field::__F3),
                            "rm_publisher" => ::core::result::Result::Ok(__Field::__F4),
                            "rm_release" => ::core::result::Result::Ok(__Field::__F5),
                            "class_definitions" => ::core::result::Result::Ok(__Field::__F6),
                            "used_models" => ::core::result::Result::Ok(__Field::__F7),
                            "modules" => ::core::result::Result::Ok(__Field::__F8),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_MODEL",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_model::BmmModel;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_MODEL` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<_> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_MODEL"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("packages"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_publisher"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_release"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("class_definitions"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("used_models"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("modules"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model::BmmModel {
                    name: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                    documentation: __s1.flatten(),
                    extensions: __s2.flatten(),
                    packages: __s3.flatten(),
                    rm_publisher: __s4
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("rm_publisher"))?,
                    rm_release: __s5
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("rm_release"))?,
                    class_definitions: __s6.flatten(),
                    used_models: __s7,
                    modules: __s8.flatten(),
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "BMM_MODEL", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::model_access::bmm_model_access::BmmModelAccess {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self
            .schema_directories
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.all_schemas.is_some() {
            __n += 1;
        }
        if self.bmm_models.is_some() {
            __n += 1;
        }
        if self.matching_bmm_models.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_MODEL_ACCESS", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_MODEL_ACCESS")?;
        if let Some(__v) = &self.schema_directories
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "schema_directories", __v)?;
        }
        if let Some(__v) = &self.all_schemas {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "all_schemas", __v)?;
        }
        if let Some(__v) = &self.bmm_models {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_models", __v)?;
        }
        if let Some(__v) = &self.matching_bmm_models {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "matching_bmm_models", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::model_access::bmm_model_access::BmmModelAccess
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "all_schemas",
            "bmm_models",
            "matching_bmm_models",
            "schema_directories",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "schema_directories" => ::core::result::Result::Ok(__Field::__F0),
                            "all_schemas" => ::core::result::Result::Ok(__Field::__F1),
                            "bmm_models" => ::core::result::Result::Ok(__Field::__F2),
                            "matching_bmm_models" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_MODEL_ACCESS",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::model_access::bmm_model_access::BmmModelAccess;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_MODEL_ACCESS` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<_> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_MODEL_ACCESS"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_directories"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("all_schemas"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_models"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("matching_bmm_models"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::model_access::bmm_model_access::BmmModelAccess {
                        schema_directories: __s0,
                        all_schemas: __s1.flatten(),
                        bmm_models: __s2.flatten(),
                        matching_bmm_models: __s3.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_MODEL_ACCESS",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_model_element::BmmModelElement {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmConstant(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmContainerProperty(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmFunction(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmGenericClass(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmGenericParameter(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmLocal(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmModel(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmPackage(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmParameter(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmProcedure(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmResult(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmSelf(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmSimpleClass(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmSingleton(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmUnitaryProperty(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm::core::bmm_model_element::BmmModelElement {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_CONSTANT",
            "BMM_CONTAINER_PROPERTY",
            "BMM_ENUMERATION",
            "BMM_ENUMERATION_INTEGER",
            "BMM_ENUMERATION_STRING",
            "BMM_FUNCTION",
            "BMM_GENERIC_CLASS",
            "BMM_GENERIC_PARAMETER",
            "BMM_INDEXED_CONTAINER_PROPERTY",
            "BMM_LOCAL",
            "BMM_MODEL",
            "BMM_PACKAGE",
            "BMM_PARAMETER",
            "BMM_PROCEDURE",
            "BMM_RESULT",
            "BMM_SELF",
            "BMM_SIMPLE_CLASS",
            "BMM_SINGLETON",
            "BMM_UNITARY_PROPERTY",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_model_element::BmmModelElement;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_MODEL_ELEMENT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_CONSTANT" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmConstant(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_FUNCTION" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmFunction(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_CLASS" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmGenericClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_PARAMETER" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmGenericParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_LOCAL" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmLocal(::serde::Deserialize::deserialize(__rest)?)),
"BMM_MODEL" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmModel(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PACKAGE" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmPackage(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PARAMETER" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmProcedure(::serde::Deserialize::deserialize(__rest)?)),
"BMM_RESULT" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmResult(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SELF" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmSelf(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_CLASS" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SINGLETON" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmSingleton(::serde::Deserialize::deserialize(__rest)?)),
"BMM_UNITARY_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_model_element::BmmModelElement::BmmUnitaryProperty(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_MODEL_ELEMENT", __other, "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_FUNCTION, BMM_GENERIC_CLASS, BMM_GENERIC_PARAMETER, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_MODEL, BMM_PACKAGE, BMM_PARAMETER, BMM_PROCEDURE, BMM_RESULT, BMM_SELF, BMM_SIMPLE_CLASS, BMM_SINGLETON, BMM_UNITARY_PROPERTY")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_MODEL_ELEMENT",
                            &__other,
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_FUNCTION, BMM_GENERIC_CLASS, BMM_GENERIC_PARAMETER, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_MODEL, BMM_PACKAGE, BMM_PARAMETER, BMM_PROCEDURE, BMM_RESULT, BMM_SELF, BMM_SIMPLE_CLASS, BMM_SINGLETON, BMM_UNITARY_PROPERTY",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_MODEL_ELEMENT",
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_FUNCTION, BMM_GENERIC_CLASS, BMM_GENERIC_PARAMETER, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_MODEL, BMM_PACKAGE, BMM_PARAMETER, BMM_PROCEDURE, BMM_RESULT, BMM_SELF, BMM_SIMPLE_CLASS, BMM_SINGLETON, BMM_UNITARY_PROPERTY",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm3::core::model::bmm_model_metadata::BmmModelMetadataData
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_MODEL_METADATA", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_MODEL_METADATA")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_publisher",
            &self.rm_publisher,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_release", &self.rm_release)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::model::bmm_model_metadata::BmmModelMetadataData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["rm_publisher", "rm_release"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_publisher" => ::core::result::Result::Ok(__Field::__F0),
                            "rm_release" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_MODEL_METADATA",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::model::bmm_model_metadata::BmmModelMetadataData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_MODEL_METADATA` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_MODEL_METADATA"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_publisher"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_release"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::model::bmm_model_metadata::BmmModelMetadataData {
                        rm_publisher: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_publisher"))?,
                        rm_release: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_release"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_MODEL_METADATA",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::model::bmm_model_metadata::BmmModelMetadata {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm3::core::model::bmm_model_metadata::BmmModelMetadata::BmmModel(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::core::model::bmm_model_metadata::BmmModelMetadata::BmmModelMetadata(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::model::bmm_model_metadata::BmmModelMetadata
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_MODEL", "BMM_MODEL_METADATA"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::model::bmm_model_metadata::BmmModelMetadata;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_MODEL_METADATA` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_MODEL" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::model::bmm_model_metadata::BmmModelMetadata::BmmModel(::serde::Deserialize::deserialize(__rest)?)),
"BMM_MODEL_METADATA" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::model::bmm_model_metadata::BmmModelMetadata::BmmModelMetadata(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_MODEL_METADATA", __other, "BMM_MODEL, BMM_MODEL_METADATA")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_MODEL_METADATA",
                            &__other,
                            "BMM_MODEL, BMM_MODEL_METADATA",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::bmm3::core::model::bmm_model_metadata::BmmModelMetadata::BmmModelMetadata(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::entity::bmm_model_type::BmmModelType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::core::entity::bmm_model_type::BmmModelType::BmmGenericType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::entity::bmm_model_type::BmmModelType::BmmSimpleType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::entity::bmm_model_type::BmmModelType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_GENERIC_TYPE", "BMM_SIMPLE_TYPE"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::entity::bmm_model_type::BmmModelType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_MODEL_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_GENERIC_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_model_type::BmmModelType::BmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_model_type::BmmModelType::BmmSimpleType(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_MODEL_TYPE", __other, "BMM_GENERIC_TYPE, BMM_SIMPLE_TYPE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_MODEL_TYPE",
                            &__other,
                            "BMM_GENERIC_TYPE, BMM_SIMPLE_TYPE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_MODEL_TYPE",
                            "BMM_GENERIC_TYPE, BMM_SIMPLE_TYPE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::entity::bmm_module::BmmModule {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::core::entity::bmm_module::BmmModule::BmmGenericClass(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::entity::bmm_module::BmmModule::BmmSimpleClass(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::core::entity::bmm_module::BmmModule {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_ENUMERATION",
            "BMM_ENUMERATION_INTEGER",
            "BMM_ENUMERATION_STRING",
            "BMM_GENERIC_CLASS",
            "BMM_SIMPLE_CLASS",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::entity::bmm_module::BmmModule;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_MODULE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_ENUMERATION" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_module::BmmModule::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_module::BmmModule::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_module::BmmModule::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_CLASS" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_module::BmmModule::BmmGenericClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_CLASS" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_module::BmmModule::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_MODULE", __other, "BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_GENERIC_CLASS, BMM_SIMPLE_CLASS")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_MODULE",
                            &__other,
                            "BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_GENERIC_CLASS, BMM_SIMPLE_CLASS",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_MODULE",
                            "BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_GENERIC_CLASS, BMM_SIMPLE_CLASS",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_open_type::BmmOpenType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_OPEN_TYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_OPEN_TYPE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "generic_constraint",
            &self.generic_constraint,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm::core::bmm_open_type::BmmOpenType {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["generic_constraint"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "generic_constraint" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_OPEN_TYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_open_type::BmmOpenType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_OPEN_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_OPEN_TYPE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("generic_constraint"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_open_type::BmmOpenType {
                    generic_constraint: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("generic_constraint"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_OPEN_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_package::BmmPackage {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.packages.is_some() {
            __n += 1;
        }
        if self.members.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_PACKAGE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_PACKAGE")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        if let Some(__v) = &self.packages {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "packages", __v)?;
        }
        if let Some(__v) = &self.members
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "members", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm::core::bmm_package::BmmPackage {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["documentation", "extensions", "members", "name", "packages"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "packages" => ::core::result::Result::Ok(__Field::__F3),
                            "members" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_PACKAGE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_package::BmmPackage;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_PACKAGE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_PACKAGE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("packages"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("members"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_package::BmmPackage {
                    name: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                    documentation: __s1.flatten(),
                    extensions: __s2.flatten(),
                    packages: __s3.flatten(),
                    members: __s4,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_PACKAGE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_package_container::BmmPackageContainer {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm::core::bmm_package_container::BmmPackageContainer::BmmModel(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_package_container::BmmPackageContainer::BmmPackage(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm::core::bmm_package_container::BmmPackageContainer
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_MODEL", "BMM_PACKAGE"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_package_container::BmmPackageContainer;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_PACKAGE_CONTAINER` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_MODEL" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_package_container::BmmPackageContainer::BmmModel(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PACKAGE" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_package_container::BmmPackageContainer::BmmPackage(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_PACKAGE_CONTAINER", __other, "BMM_MODEL, BMM_PACKAGE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_PACKAGE_CONTAINER",
                            &__other,
                            "BMM_MODEL, BMM_PACKAGE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_PACKAGE_CONTAINER",
                            "BMM_MODEL, BMM_PACKAGE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::feature::bmm_parameter::BmmParameter {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_nullable.is_some() {
            __n += 1;
        }
        if self.direction.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_PARAMETER", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_PARAMETER")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        if let Some(__v) = &self.direction {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "direction", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::feature::bmm_parameter::BmmParameter
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "direction",
            "documentation",
            "extensions",
            "is_nullable",
            "name",
            "type",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "type" => ::core::result::Result::Ok(__Field::__F3),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F4),
                            "direction" => ::core::result::Result::Ok(__Field::__F5),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_PARAMETER",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::feature::bmm_parameter::BmmParameter;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_PARAMETER` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_PARAMETER"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_nullable"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("direction"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::feature::bmm_parameter::BmmParameter {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s1.flatten(),
                        extensions: __s2.flatten(),
                        r#type: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        is_nullable: __s4.flatten(),
                        direction: __s5.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_PARAMETER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::entity::bmm_parameter_type::BmmParameterType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.type_constraint.is_some() {
            __n += 1;
        }
        if self.inheritance_precursor.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_PARAMETER_TYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_PARAMETER_TYPE")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.type_constraint {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_constraint", __v)?;
        }
        if let Some(__v) = &self.inheritance_precursor {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "inheritance_precursor",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::entity::bmm_parameter_type::BmmParameterType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["inheritance_precursor", "name", "type_constraint"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_constraint" => ::core::result::Result::Ok(__Field::__F1),
                            "inheritance_precursor" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_PARAMETER_TYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::entity::bmm_parameter_type::BmmParameterType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_PARAMETER_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_PARAMETER_TYPE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type_constraint"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("inheritance_precursor"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::entity::bmm_parameter_type::BmmParameterType {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        type_constraint: __s1.flatten(),
                        inheritance_precursor: __s2.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_PARAMETER_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValueData
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.value.is_some() {
            __n += 1;
        }
        if self.syntax.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_PRIMITIVE_VALUE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_PRIMITIVE_VALUE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "value_literal",
            &self.value_literal,
        )?;
        if let Some(__v) = &self.value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "value", __v)?;
        }
        if let Some(__v) = &self.syntax {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "syntax", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValueData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["syntax", "type", "value", "value_literal"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "value_literal" => ::core::result::Result::Ok(__Field::__F0),
                            "value" => ::core::result::Result::Ok(__Field::__F1),
                            "syntax" => ::core::result::Result::Ok(__Field::__F2),
                            "type" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_PRIMITIVE_VALUE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValueData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_PRIMITIVE_VALUE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_PRIMITIVE_VALUE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value_literal"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("syntax"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValueData {
value_literal: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("value_literal"))?,
value: __s1.flatten(),
syntax: __s2.flatten(),
r#type: __s3.flatten().ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_PRIMITIVE_VALUE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmBooleanValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmIntegerValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmStringValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmPrimitiveValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_BOOLEAN_VALUE",
            "BMM_INTEGER_VALUE",
            "BMM_PRIMITIVE_VALUE",
            "BMM_STRING_VALUE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_PRIMITIVE_VALUE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_BOOLEAN_VALUE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmBooleanValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INTEGER_VALUE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmIntegerValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PRIMITIVE_VALUE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STRING_VALUE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmStringValue(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_PRIMITIVE_VALUE", __other, "BMM_BOOLEAN_VALUE, BMM_INTEGER_VALUE, BMM_PRIMITIVE_VALUE, BMM_STRING_VALUE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_PRIMITIVE_VALUE",
                            &__other,
                            "BMM_BOOLEAN_VALUE, BMM_INTEGER_VALUE, BMM_PRIMITIVE_VALUE, BMM_STRING_VALUE",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::feature::bmm_procedure::BmmProcedure {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_nullable.is_some() {
            __n += 1;
        }
        if self.is_synthesised_generic.is_some() {
            __n += 1;
        }
        if self
            .feature_extensions
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.parameters.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self
            .pre_conditions
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self
            .post_conditions
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.definition.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_PROCEDURE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_PROCEDURE")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        if let Some(__v) = &self.is_synthesised_generic {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_synthesised_generic",
                __v,
            )?;
        }
        if let Some(__v) = &self.feature_extensions
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "feature_extensions", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "group", &self.group)?;
        if let Some(__v) = &self.parameters
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parameters", __v)?;
        }
        if let Some(__v) = &self.pre_conditions
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "pre_conditions", __v)?;
        }
        if let Some(__v) = &self.post_conditions
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "post_conditions", __v)?;
        }
        if let Some(__v) = &self.definition {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::feature::bmm_procedure::BmmProcedure
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "definition",
            "documentation",
            "extensions",
            "feature_extensions",
            "group",
            "is_nullable",
            "is_synthesised_generic",
            "name",
            "parameters",
            "post_conditions",
            "pre_conditions",
            "type",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "type" => ::core::result::Result::Ok(__Field::__F3),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F4),
                            "is_synthesised_generic" => ::core::result::Result::Ok(__Field::__F5),
                            "feature_extensions" => ::core::result::Result::Ok(__Field::__F6),
                            "group" => ::core::result::Result::Ok(__Field::__F7),
                            "parameters" => ::core::result::Result::Ok(__Field::__F8),
                            "pre_conditions" => ::core::result::Result::Ok(__Field::__F9),
                            "post_conditions" => ::core::result::Result::Ok(__Field::__F10),
                            "definition" => ::core::result::Result::Ok(__Field::__F11),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_PROCEDURE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::feature::bmm_procedure::BmmProcedure;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_PROCEDURE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<_> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<_> = None;
                let mut __s9: ::core::option::Option<_> = None;
                let mut __s10: ::core::option::Option<_> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_PROCEDURE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_nullable"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_synthesised_generic"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("feature_extensions"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("group"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parameters"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("pre_conditions"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("post_conditions"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("definition"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::feature::bmm_procedure::BmmProcedure {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s1.flatten(),
                        extensions: __s2.flatten(),
                        r#type: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        is_nullable: __s4.flatten(),
                        is_synthesised_generic: __s5.flatten(),
                        feature_extensions: __s6,
                        group: __s7
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("group"))?,
                        parameters: __s8,
                        pre_conditions: __s9,
                        post_conditions: __s10,
                        definition: __s11.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_PROCEDURE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::statement::bmm_procedure_call::BmmProcedureCall {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_PROCEDURE_CALL", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_PROCEDURE_CALL")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "agent", &self.agent)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::statement::bmm_procedure_call::BmmProcedureCall
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["agent"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "agent" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_PROCEDURE_CALL",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::statement::bmm_procedure_call::BmmProcedureCall;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_PROCEDURE_CALL` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_PROCEDURE_CALL"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("agent"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::statement::bmm_procedure_call::BmmProcedureCall {
                        agent: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("agent"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_PROCEDURE_CALL",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::entity::bmm_procedure_type::BmmProcedureType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.result_type.is_some() {
            __n += 1;
        }
        if self.argument_types.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_PROCEDURE_TYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_PROCEDURE_TYPE")?;
        if let Some(__v) = &self.result_type {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "result_type", __v)?;
        }
        if let Some(__v) = &self.argument_types {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "argument_types", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::entity::bmm_procedure_type::BmmProcedureType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["argument_types", "result_type"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "result_type" => ::core::result::Result::Ok(__Field::__F0),
                            "argument_types" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_PROCEDURE_TYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::entity::bmm_procedure_type::BmmProcedureType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_PROCEDURE_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_PROCEDURE_TYPE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("result_type"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("argument_types"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::entity::bmm_procedure_type::BmmProcedureType {
                        result_type: __s0.flatten(),
                        argument_types: __s1.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_PROCEDURE_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_property::BmmProperty {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm::core::bmm_property::BmmProperty::BmmContainerProperty(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_property::BmmProperty::BmmUnitaryProperty(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm::core::bmm_property::BmmProperty {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_CONTAINER_PROPERTY",
            "BMM_INDEXED_CONTAINER_PROPERTY",
            "BMM_UNITARY_PROPERTY",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_property::BmmProperty;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_PROPERTY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_property::BmmProperty::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_property::BmmProperty::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_UNITARY_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_property::BmmProperty::BmmUnitaryProperty(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_PROPERTY", __other, "BMM_CONTAINER_PROPERTY, BMM_INDEXED_CONTAINER_PROPERTY, BMM_UNITARY_PROPERTY")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_PROPERTY",
                            &__other,
                            "BMM_CONTAINER_PROPERTY, BMM_INDEXED_CONTAINER_PROPERTY, BMM_UNITARY_PROPERTY",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_PROPERTY",
                            "BMM_CONTAINER_PROPERTY, BMM_INDEXED_CONTAINER_PROPERTY, BMM_UNITARY_PROPERTY",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::entity::bmm_property_type::BmmPropertyType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_PROPERTY_TYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_PROPERTY_TYPE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "result_type",
            &self.result_type,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::entity::bmm_property_type::BmmPropertyType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["result_type"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "result_type" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_PROPERTY_TYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::entity::bmm_property_type::BmmPropertyType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_PROPERTY_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_PROPERTY_TYPE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("result_type"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::entity::bmm_property_type::BmmPropertyType {
                        result_type: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("result_type"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_PROPERTY_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm3::core::feature::bmm_readonly_variable::BmmReadonlyVariable
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm3::core::feature::bmm_readonly_variable::BmmReadonlyVariable::BmmParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::core::feature::bmm_readonly_variable::BmmReadonlyVariable::BmmSelf(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::feature::bmm_readonly_variable::BmmReadonlyVariable
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_PARAMETER", "BMM_SELF"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm3::core::feature::bmm_readonly_variable::BmmReadonlyVariable;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_READONLY_VARIABLE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_PARAMETER" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_readonly_variable::BmmReadonlyVariable::BmmParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SELF" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_readonly_variable::BmmReadonlyVariable::BmmSelf(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_READONLY_VARIABLE", __other, "BMM_PARAMETER, BMM_SELF")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_READONLY_VARIABLE",
                            &__other,
                            "BMM_PARAMETER, BMM_SELF",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_READONLY_VARIABLE",
                            "BMM_PARAMETER, BMM_SELF",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::feature::bmm_result::BmmResult {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_nullable.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_RESULT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_RESULT")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::core::feature::bmm_result::BmmResult {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["documentation", "extensions", "is_nullable", "name", "type"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "type" => ::core::result::Result::Ok(__Field::__F3),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_RESULT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::feature::bmm_result::BmmResult;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_RESULT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_RESULT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_nullable"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::feature::bmm_result::BmmResult {
                        name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("Result")),
                        documentation: __s1.flatten(),
                        extensions: __s2.flatten(),
                        r#type: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        is_nullable: __s4.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "BMM_RESULT", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::feature::bmm_routine::BmmRoutine {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::core::feature::bmm_routine::BmmRoutine::BmmFunction(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::feature::bmm_routine::BmmRoutine::BmmProcedure(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::core::feature::bmm_routine::BmmRoutine {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_FUNCTION", "BMM_PROCEDURE"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::feature::bmm_routine::BmmRoutine;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_ROUTINE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_FUNCTION" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_routine::BmmRoutine::BmmFunction(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_routine::BmmRoutine::BmmProcedure(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_ROUTINE", __other, "BMM_FUNCTION, BMM_PROCEDURE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_ROUTINE",
                            &__other,
                            "BMM_FUNCTION, BMM_PROCEDURE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_ROUTINE",
                            "BMM_FUNCTION, BMM_PROCEDURE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm3::core::feature::bmm_routine_definition::BmmRoutineDefinition
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm3::core::feature::bmm_routine_definition::BmmRoutineDefinition::BmmExternalRoutine(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::core::feature::bmm_routine_definition::BmmRoutineDefinition::BmmLocalRoutine(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::feature::bmm_routine_definition::BmmRoutineDefinition
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_EXTERNAL_ROUTINE", "BMM_LOCAL_ROUTINE"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm3::core::feature::bmm_routine_definition::BmmRoutineDefinition;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_ROUTINE_DEFINITION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_EXTERNAL_ROUTINE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_routine_definition::BmmRoutineDefinition::BmmExternalRoutine(::serde::Deserialize::deserialize(__rest)?)),
"BMM_LOCAL_ROUTINE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_routine_definition::BmmRoutineDefinition::BmmLocalRoutine(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_ROUTINE_DEFINITION", __other, "BMM_EXTERNAL_ROUTINE, BMM_LOCAL_ROUTINE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_ROUTINE_DEFINITION",
                            &__other,
                            "BMM_EXTERNAL_ROUTINE, BMM_LOCAL_ROUTINE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_ROUTINE_DEFINITION",
                            "BMM_EXTERNAL_ROUTINE, BMM_LOCAL_ROUTINE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::entity::bmm_routine_type::BmmRoutineTypeData {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.argument_types.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_ROUTINE_TYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_ROUTINE_TYPE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "result_type",
            &self.result_type,
        )?;
        if let Some(__v) = &self.argument_types {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "argument_types", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::entity::bmm_routine_type::BmmRoutineTypeData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["argument_types", "result_type"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "result_type" => ::core::result::Result::Ok(__Field::__F0),
                            "argument_types" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_ROUTINE_TYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::entity::bmm_routine_type::BmmRoutineTypeData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_ROUTINE_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_ROUTINE_TYPE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("result_type"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("argument_types"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::entity::bmm_routine_type::BmmRoutineTypeData {
                        result_type: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("result_type"))?,
                        argument_types: __s1.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_ROUTINE_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::entity::bmm_routine_type::BmmRoutineType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::core::entity::bmm_routine_type::BmmRoutineType::BmmFunctionType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::bmm3::core::entity::bmm_routine_type::BmmRoutineType::BmmProcedureType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::bmm3::core::entity::bmm_routine_type::BmmRoutineType::BmmRoutineType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::entity::bmm_routine_type::BmmRoutineType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_FUNCTION_TYPE",
            "BMM_PROCEDURE_TYPE",
            "BMM_ROUTINE_TYPE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::entity::bmm_routine_type::BmmRoutineType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_ROUTINE_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_FUNCTION_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_routine_type::BmmRoutineType::BmmFunctionType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_routine_type::BmmRoutineType::BmmProcedureType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ROUTINE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_routine_type::BmmRoutineType::BmmRoutineType(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_ROUTINE_TYPE", __other, "BMM_FUNCTION_TYPE, BMM_PROCEDURE_TYPE, BMM_ROUTINE_TYPE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_ROUTINE_TYPE",
                            &__other,
                            "BMM_FUNCTION_TYPE, BMM_PROCEDURE_TYPE, BMM_ROUTINE_TYPE",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_routine_type::BmmRoutineType::BmmRoutineType(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::model_access::bmm_schema::BmmSchema {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 10usize;
        if self.includes.is_some() {
            __n += 1;
        }
        if self.bmm_model.is_some() {
            __n += 1;
        }
        if self.model_name.is_some() {
            __n += 1;
        }
        if self
            .schema_contributors
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_SCHEMA", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_SCHEMA")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_publisher",
            &self.rm_publisher,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_release", &self.rm_release)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "bmm_version",
            &self.bmm_version,
        )?;
        if let Some(__v) = &self.includes {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "includes", __v)?;
        }
        if let Some(__v) = &self.bmm_model {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_model", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "state", &self.state)?;
        if let Some(__v) = &self.model_name {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "model_name", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "schema_name",
            &self.schema_name,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "schema_revision",
            &self.schema_revision,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "schema_lifecycle_state",
            &self.schema_lifecycle_state,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "schema_author",
            &self.schema_author,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "schema_description",
            &self.schema_description,
        )?;
        if let Some(__v) = &self.schema_contributors
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "schema_contributors", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::model_access::bmm_schema::BmmSchema {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "bmm_model",
            "bmm_version",
            "includes",
            "model_name",
            "rm_publisher",
            "rm_release",
            "schema_author",
            "schema_contributors",
            "schema_description",
            "schema_lifecycle_state",
            "schema_name",
            "schema_revision",
            "state",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_publisher" => ::core::result::Result::Ok(__Field::__F0),
                            "rm_release" => ::core::result::Result::Ok(__Field::__F1),
                            "bmm_version" => ::core::result::Result::Ok(__Field::__F2),
                            "includes" => ::core::result::Result::Ok(__Field::__F3),
                            "bmm_model" => ::core::result::Result::Ok(__Field::__F4),
                            "state" => ::core::result::Result::Ok(__Field::__F5),
                            "model_name" => ::core::result::Result::Ok(__Field::__F6),
                            "schema_name" => ::core::result::Result::Ok(__Field::__F7),
                            "schema_revision" => ::core::result::Result::Ok(__Field::__F8),
                            "schema_lifecycle_state" => ::core::result::Result::Ok(__Field::__F9),
                            "schema_author" => ::core::result::Result::Ok(__Field::__F10),
                            "schema_description" => ::core::result::Result::Ok(__Field::__F11),
                            "schema_contributors" => ::core::result::Result::Ok(__Field::__F12),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_SCHEMA",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::model_access::bmm_schema::BmmSchema;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_SCHEMA` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_SCHEMA"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_publisher"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_release"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_version"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("includes"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_model"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("state"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("model_name"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_name"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_revision"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_lifecycle_state"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_author"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_description"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_contributors"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm3::model_access::bmm_schema::BmmSchema {
                    rm_publisher: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("rm_publisher"))?,
                    rm_release: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("rm_release"))?,
                    bmm_version: __s2
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("bmm_version"))?,
                    includes: __s3.flatten(),
                    bmm_model: __s4.flatten(),
                    state: __s5
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("state"))?,
                    model_name: __s6.flatten(),
                    schema_name: __s7
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("schema_name"))?,
                    schema_revision: __s8
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("schema_revision"))?,
                    schema_lifecycle_state: __s9.flatten().ok_or_else(|| {
                        ::serde::de::Error::missing_field("schema_lifecycle_state")
                    })?,
                    schema_author: __s10
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("schema_author"))?,
                    schema_description: __s11
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("schema_description"))?,
                    schema_contributors: __s12,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "BMM_SCHEMA", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_schema_core::BmmSchemaCoreData {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 8usize;
        if self
            .schema_contributors
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.archetype_parent_class.is_some() {
            __n += 1;
        }
        if self.archetype_data_value_parent_class.is_some() {
            __n += 1;
        }
        if self
            .archetype_rm_closure_packages
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.archetype_visualise_descendants_of.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_SCHEMA_CORE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_SCHEMA_CORE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_publisher",
            &self.rm_publisher,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_release", &self.rm_release)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "schema_name",
            &self.schema_name,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "schema_revision",
            &self.schema_revision,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "schema_lifecycle_state",
            &self.schema_lifecycle_state,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "schema_author",
            &self.schema_author,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "schema_description",
            &self.schema_description,
        )?;
        if let Some(__v) = &self.schema_contributors
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "schema_contributors", __v)?;
        }
        if let Some(__v) = &self.archetype_parent_class {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "archetype_parent_class",
                __v,
            )?;
        }
        if let Some(__v) = &self.archetype_data_value_parent_class {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "archetype_data_value_parent_class",
                __v,
            )?;
        }
        if let Some(__v) = &self.archetype_rm_closure_packages
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "archetype_rm_closure_packages",
                __v,
            )?;
        }
        if let Some(__v) = &self.archetype_visualise_descendants_of {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "archetype_visualise_descendants_of",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm::core::bmm_schema_core::BmmSchemaCoreData {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "archetype_data_value_parent_class",
            "archetype_parent_class",
            "archetype_rm_closure_packages",
            "archetype_visualise_descendants_of",
            "rm_publisher",
            "rm_release",
            "schema_author",
            "schema_contributors",
            "schema_description",
            "schema_lifecycle_state",
            "schema_name",
            "schema_revision",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_publisher" => ::core::result::Result::Ok(__Field::__F0),
                            "rm_release" => ::core::result::Result::Ok(__Field::__F1),
                            "schema_name" => ::core::result::Result::Ok(__Field::__F2),
                            "schema_revision" => ::core::result::Result::Ok(__Field::__F3),
                            "schema_lifecycle_state" => ::core::result::Result::Ok(__Field::__F4),
                            "schema_author" => ::core::result::Result::Ok(__Field::__F5),
                            "schema_description" => ::core::result::Result::Ok(__Field::__F6),
                            "schema_contributors" => ::core::result::Result::Ok(__Field::__F7),
                            "archetype_parent_class" => ::core::result::Result::Ok(__Field::__F8),
                            "archetype_data_value_parent_class" => {
                                ::core::result::Result::Ok(__Field::__F9)
                            }
                            "archetype_rm_closure_packages" => {
                                ::core::result::Result::Ok(__Field::__F10)
                            }
                            "archetype_visualise_descendants_of" => {
                                ::core::result::Result::Ok(__Field::__F11)
                            }
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_SCHEMA_CORE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_schema_core::BmmSchemaCoreData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_SCHEMA_CORE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<_> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<_> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_SCHEMA_CORE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_publisher"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_release"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_name"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_revision"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_lifecycle_state"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_author"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_description"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_contributors"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("archetype_parent_class"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "archetype_data_value_parent_class",
                                    ),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "archetype_rm_closure_packages",
                                    ),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "archetype_visualise_descendants_of",
                                    ),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm::core::bmm_schema_core::BmmSchemaCoreData {
                        rm_publisher: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_publisher"))?,
                        rm_release: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_release"))?,
                        schema_name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("schema_name"))?,
                        schema_revision: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("schema_revision"))?,
                        schema_lifecycle_state: __s4.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("schema_lifecycle_state")
                        })?,
                        schema_author: __s5
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("schema_author"))?,
                        schema_description: __s6.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("schema_description")
                        })?,
                        schema_contributors: __s7,
                        archetype_parent_class: __s8.flatten(),
                        archetype_data_value_parent_class: __s9.flatten(),
                        archetype_rm_closure_packages: __s10,
                        archetype_visualise_descendants_of: __s11.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_SCHEMA_CORE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_schema_core::BmmSchemaCore {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm::core::bmm_schema_core::BmmSchemaCore::PBmmSchema(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_schema_core::BmmSchemaCore::BmmSchemaCore(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm::core::bmm_schema_core::BmmSchemaCore {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_SCHEMA_CORE", "P_BMM_SCHEMA"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_schema_core::BmmSchemaCore;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_SCHEMA_CORE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_SCHEMA_CORE" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_schema_core::BmmSchemaCore::BmmSchemaCore(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SCHEMA" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_schema_core::BmmSchemaCore::PBmmSchema(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_SCHEMA_CORE", __other, "BMM_SCHEMA_CORE, P_BMM_SCHEMA")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_SCHEMA_CORE",
                            &__other,
                            "BMM_SCHEMA_CORE, P_BMM_SCHEMA",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(
                            crate::v2_4::bmm::core::bmm_schema_core::BmmSchemaCore::BmmSchemaCore(
                                ::serde::Deserialize::deserialize(__rest)?,
                            ),
                        )
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm3::model_access::bmm_schema_descriptor::BmmSchemaDescriptor
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.bmm_schema.is_some() {
            __n += 1;
        }
        if self.bmm_model.is_some() {
            __n += 1;
        }
        if self.includes.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_SCHEMA_DESCRIPTOR", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "BMM_SCHEMA_DESCRIPTOR",
        )?;
        if let Some(__v) = &self.bmm_schema {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_schema", __v)?;
        }
        if let Some(__v) = &self.bmm_model {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_model", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "schema_id", &self.schema_id)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "meta_data", &self.meta_data)?;
        if let Some(__v) = &self.includes
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "includes", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::model_access::bmm_schema_descriptor::BmmSchemaDescriptor
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "bmm_model",
            "bmm_schema",
            "includes",
            "meta_data",
            "schema_id",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "bmm_schema" => ::core::result::Result::Ok(__Field::__F0),
                            "bmm_model" => ::core::result::Result::Ok(__Field::__F1),
                            "schema_id" => ::core::result::Result::Ok(__Field::__F2),
                            "meta_data" => ::core::result::Result::Ok(__Field::__F3),
                            "includes" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_SCHEMA_DESCRIPTOR",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm3::model_access::bmm_schema_descriptor::BmmSchemaDescriptor;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_SCHEMA_DESCRIPTOR` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "BMM_SCHEMA_DESCRIPTOR",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_schema"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_model"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_id"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("meta_data"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("includes"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::model_access::bmm_schema_descriptor::BmmSchemaDescriptor {
                        bmm_schema: __s0.flatten(),
                        bmm_model: __s1.flatten(),
                        schema_id: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("schema_id"))?,
                        meta_data: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("meta_data"))?,
                        includes: __s4,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_SCHEMA_DESCRIPTOR",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::feature::bmm_self::BmmSelf {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_nullable.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_SELF", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_SELF")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::core::feature::bmm_self::BmmSelf {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["documentation", "extensions", "is_nullable", "name", "type"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "type" => ::core::result::Result::Ok(__Field::__F3),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v, "BMM_SELF", __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::feature::bmm_self::BmmSelf;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_SELF` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_SELF"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_nullable"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_self::BmmSelf {
                    name: __s0
                        .flatten()
                        .unwrap_or(::std::string::String::from("Self")),
                    documentation: __s1.flatten(),
                    extensions: __s2.flatten(),
                    r#type: __s3
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                    is_nullable: __s4.flatten(),
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "BMM_SELF", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::entity::bmm_signature::BmmSignatureData {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_SIGNATURE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_SIGNATURE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "result_type",
            &self.result_type,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::entity::bmm_signature::BmmSignatureData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["result_type"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "result_type" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_SIGNATURE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::entity::bmm_signature::BmmSignatureData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_SIGNATURE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_SIGNATURE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("result_type"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::entity::bmm_signature::BmmSignatureData {
                        result_type: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("result_type"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_SIGNATURE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::entity::bmm_signature::BmmSignature {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::core::entity::bmm_signature::BmmSignature::BmmPropertyType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::entity::bmm_signature::BmmSignature::BmmRoutineType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::entity::bmm_signature::BmmSignature::BmmSignature(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::entity::bmm_signature::BmmSignature
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_FUNCTION_TYPE",
            "BMM_PROCEDURE_TYPE",
            "BMM_PROPERTY_TYPE",
            "BMM_ROUTINE_TYPE",
            "BMM_SIGNATURE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::entity::bmm_signature::BmmSignature;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_SIGNATURE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_FUNCTION_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_signature::BmmSignature::BmmRoutineType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_signature::BmmSignature::BmmRoutineType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROPERTY_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_signature::BmmSignature::BmmPropertyType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ROUTINE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_signature::BmmSignature::BmmRoutineType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIGNATURE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_signature::BmmSignature::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_SIGNATURE", __other, "BMM_FUNCTION_TYPE, BMM_PROCEDURE_TYPE, BMM_PROPERTY_TYPE, BMM_ROUTINE_TYPE, BMM_SIGNATURE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_SIGNATURE",
                            &__other,
                            "BMM_FUNCTION_TYPE, BMM_PROCEDURE_TYPE, BMM_PROPERTY_TYPE, BMM_ROUTINE_TYPE, BMM_SIGNATURE",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_signature::BmmSignature::BmmSignature(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::entity::bmm_simple_class::BmmSimpleClassData {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self
            .feature_groups
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.features.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.ancestors.is_some() {
            __n += 1;
        }
        if self.properties.is_some() {
            __n += 1;
        }
        if self
            .immediate_descendants
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.static_properties.is_some() {
            __n += 1;
        }
        if self.functions.is_some() {
            __n += 1;
        }
        if self.procedures.is_some() {
            __n += 1;
        }
        if self.is_primitive.is_some() {
            __n += 1;
        }
        if self.is_abstract.is_some() {
            __n += 1;
        }
        if self.invariants.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.creators.is_some() {
            __n += 1;
        }
        if self.converters.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_SIMPLE_CLASS", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_SIMPLE_CLASS")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        if let Some(__v) = &self.feature_groups
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "feature_groups", __v)?;
        }
        if let Some(__v) = &self.features
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "features", __v)?;
        }
        if let Some(__v) = &self.ancestors {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "ancestors", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "package", &self.package)?;
        if let Some(__v) = &self.properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "properties", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "source_schema_id",
            &self.source_schema_id,
        )?;
        if let Some(__v) = &self.immediate_descendants
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "immediate_descendants",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_override",
            &self.is_override,
        )?;
        if let Some(__v) = &self.static_properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "static_properties", __v)?;
        }
        if let Some(__v) = &self.functions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "functions", __v)?;
        }
        if let Some(__v) = &self.procedures {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "procedures", __v)?;
        }
        if let Some(__v) = &self.is_primitive {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_primitive", __v)?;
        }
        if let Some(__v) = &self.is_abstract {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_abstract", __v)?;
        }
        if let Some(__v) = &self.invariants
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "invariants", __v)?;
        }
        if let Some(__v) = &self.creators {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "creators", __v)?;
        }
        if let Some(__v) = &self.converters {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "converters", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::entity::bmm_simple_class::BmmSimpleClassData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "ancestors",
            "converters",
            "creators",
            "documentation",
            "extensions",
            "feature_groups",
            "features",
            "functions",
            "immediate_descendants",
            "invariants",
            "is_abstract",
            "is_override",
            "is_primitive",
            "name",
            "package",
            "procedures",
            "properties",
            "source_schema_id",
            "static_properties",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
            __F14,
            __F15,
            __F16,
            __F17,
            __F18,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "feature_groups" => ::core::result::Result::Ok(__Field::__F3),
                            "features" => ::core::result::Result::Ok(__Field::__F4),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F5),
                            "package" => ::core::result::Result::Ok(__Field::__F6),
                            "properties" => ::core::result::Result::Ok(__Field::__F7),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F8),
                            "immediate_descendants" => ::core::result::Result::Ok(__Field::__F9),
                            "is_override" => ::core::result::Result::Ok(__Field::__F10),
                            "static_properties" => ::core::result::Result::Ok(__Field::__F11),
                            "functions" => ::core::result::Result::Ok(__Field::__F12),
                            "procedures" => ::core::result::Result::Ok(__Field::__F13),
                            "is_primitive" => ::core::result::Result::Ok(__Field::__F14),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F15),
                            "invariants" => ::core::result::Result::Ok(__Field::__F16),
                            "creators" => ::core::result::Result::Ok(__Field::__F17),
                            "converters" => ::core::result::Result::Ok(__Field::__F18),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_SIMPLE_CLASS",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::entity::bmm_simple_class::BmmSimpleClassData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_SIMPLE_CLASS` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<_> = None;
                let mut __s4: ::core::option::Option<_> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<_> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s14: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s15: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s16: ::core::option::Option<_> = None;
                let mut __s17: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s18: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_SIMPLE_CLASS"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("feature_groups"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("features"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("ancestors"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("package"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("properties"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("source_schema_id"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("immediate_descendants"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_override"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("static_properties"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("functions"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("procedures"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F14 => {
                            if __s14.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_primitive"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F15 => {
                            if __s15.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_abstract"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F16 => {
                            if __s16.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("invariants"),
                                );
                            }
                            __s16 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F17 => {
                            if __s17.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("creators"),
                                );
                            }
                            __s17 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F18 => {
                            if __s18.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("converters"),
                                );
                            }
                            __s18 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::entity::bmm_simple_class::BmmSimpleClassData {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s1.flatten(),
                        extensions: __s2.flatten(),
                        feature_groups: __s3,
                        features: __s4,
                        ancestors: __s5.flatten(),
                        package: __s6
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("package"))?,
                        properties: __s7.flatten(),
                        source_schema_id: __s8
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                        immediate_descendants: __s9,
                        is_override: __s10
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_override"))?,
                        static_properties: __s11.flatten(),
                        functions: __s12.flatten(),
                        procedures: __s13.flatten(),
                        is_primitive: __s14.flatten(),
                        is_abstract: __s15.flatten(),
                        invariants: __s16,
                        creators: __s17.flatten(),
                        converters: __s18.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_SIMPLE_CLASS",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::entity::bmm_simple_class::BmmSimpleClass {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::core::entity::bmm_simple_class::BmmSimpleClass::BmmEnumeration(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::bmm3::core::entity::bmm_simple_class::BmmSimpleClass::BmmSimpleClass(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::entity::bmm_simple_class::BmmSimpleClass
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_ENUMERATION",
            "BMM_ENUMERATION_INTEGER",
            "BMM_ENUMERATION_STRING",
            "BMM_SIMPLE_CLASS",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::entity::bmm_simple_class::BmmSimpleClass;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_SIMPLE_CLASS` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_ENUMERATION" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_simple_class::BmmSimpleClass::BmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_simple_class::BmmSimpleClass::BmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_simple_class::BmmSimpleClass::BmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_CLASS" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_simple_class::BmmSimpleClass::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_SIMPLE_CLASS", __other, "BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_SIMPLE_CLASS")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_SIMPLE_CLASS",
                            &__other,
                            "BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_SIMPLE_CLASS",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_simple_class::BmmSimpleClass::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::statement::bmm_simple_statement::BmmSimpleStatement {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm3::statement::bmm_simple_statement::BmmSimpleStatement::BmmAssertion(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::statement::bmm_simple_statement::BmmSimpleStatement::BmmAssignment(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::statement::bmm_simple_statement::BmmSimpleStatement::BmmDeclaration(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::statement::bmm_simple_statement::BmmSimpleStatement::BmmProcedureCall(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::statement::bmm_simple_statement::BmmSimpleStatement
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_ASSERTION",
            "BMM_ASSIGNMENT",
            "BMM_DECLARATION",
            "BMM_PROCEDURE_CALL",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::statement::bmm_simple_statement::BmmSimpleStatement;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_SIMPLE_STATEMENT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_ASSERTION" => ::core::result::Result::Ok(crate::v2_4::bmm3::statement::bmm_simple_statement::BmmSimpleStatement::BmmAssertion(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ASSIGNMENT" => ::core::result::Result::Ok(crate::v2_4::bmm3::statement::bmm_simple_statement::BmmSimpleStatement::BmmAssignment(::serde::Deserialize::deserialize(__rest)?)),
"BMM_DECLARATION" => ::core::result::Result::Ok(crate::v2_4::bmm3::statement::bmm_simple_statement::BmmSimpleStatement::BmmDeclaration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_CALL" => ::core::result::Result::Ok(crate::v2_4::bmm3::statement::bmm_simple_statement::BmmSimpleStatement::BmmProcedureCall(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_SIMPLE_STATEMENT", __other, "BMM_ASSERTION, BMM_ASSIGNMENT, BMM_DECLARATION, BMM_PROCEDURE_CALL")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_SIMPLE_STATEMENT",
                            &__other,
                            "BMM_ASSERTION, BMM_ASSIGNMENT, BMM_DECLARATION, BMM_PROCEDURE_CALL",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_SIMPLE_STATEMENT",
                            "BMM_ASSERTION, BMM_ASSIGNMENT, BMM_DECLARATION, BMM_PROCEDURE_CALL",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_simple_type::BmmSimpleType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.value_constraint.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_SIMPLE_TYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_SIMPLE_TYPE")?;
        if let Some(__v) = &self.value_constraint {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "value_constraint", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "base_class", &self.base_class)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm::core::bmm_simple_type::BmmSimpleType {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["base_class", "value_constraint"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "value_constraint" => ::core::result::Result::Ok(__Field::__F0),
                            "base_class" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_SIMPLE_TYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_simple_type::BmmSimpleType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_SIMPLE_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_SIMPLE_TYPE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value_constraint"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("base_class"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_simple_type::BmmSimpleType {
                    value_constraint: __s0.flatten(),
                    base_class: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("base_class"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_SIMPLE_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::feature::bmm_singleton::BmmSingleton {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_nullable.is_some() {
            __n += 1;
        }
        if self.is_synthesised_generic.is_some() {
            __n += 1;
        }
        if self
            .feature_extensions
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_SINGLETON", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_SINGLETON")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        if let Some(__v) = &self.is_synthesised_generic {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_synthesised_generic",
                __v,
            )?;
        }
        if let Some(__v) = &self.feature_extensions
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "feature_extensions", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "group", &self.group)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "generator", &self.generator)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::feature::bmm_singleton::BmmSingleton
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "documentation",
            "extensions",
            "feature_extensions",
            "generator",
            "group",
            "is_nullable",
            "is_synthesised_generic",
            "name",
            "type",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "type" => ::core::result::Result::Ok(__Field::__F3),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F4),
                            "is_synthesised_generic" => ::core::result::Result::Ok(__Field::__F5),
                            "feature_extensions" => ::core::result::Result::Ok(__Field::__F6),
                            "group" => ::core::result::Result::Ok(__Field::__F7),
                            "generator" => ::core::result::Result::Ok(__Field::__F8),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_SINGLETON",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::feature::bmm_singleton::BmmSingleton;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_SINGLETON` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<_> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_SINGLETON"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_nullable"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_synthesised_generic"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("feature_extensions"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("group"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("generator"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::feature::bmm_singleton::BmmSingleton {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s1.flatten(),
                        extensions: __s2.flatten(),
                        r#type: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        is_nullable: __s4.flatten(),
                        is_synthesised_generic: __s5.flatten(),
                        feature_extensions: __s6,
                        group: __s7
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("group"))?,
                        generator: __s8
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("generator"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_SINGLETON",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::statement::bmm_statement::BmmStatement {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::statement::bmm_statement::BmmStatement::BmmActionTable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::statement::bmm_statement::BmmStatement::BmmAssertion(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::statement::bmm_statement::BmmStatement::BmmAssignment(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::statement::bmm_statement::BmmStatement::BmmDeclaration(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::statement::bmm_statement::BmmStatement::BmmProcedureCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::statement::bmm_statement::BmmStatement {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_ACTION_TABLE",
            "BMM_ASSERTION",
            "BMM_ASSIGNMENT",
            "BMM_DECLARATION",
            "BMM_PROCEDURE_CALL",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::statement::bmm_statement::BmmStatement;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_STATEMENT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_ACTION_TABLE" => ::core::result::Result::Ok(crate::v2_4::bmm3::statement::bmm_statement::BmmStatement::BmmActionTable(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ASSERTION" => ::core::result::Result::Ok(crate::v2_4::bmm3::statement::bmm_statement::BmmStatement::BmmAssertion(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ASSIGNMENT" => ::core::result::Result::Ok(crate::v2_4::bmm3::statement::bmm_statement::BmmStatement::BmmAssignment(::serde::Deserialize::deserialize(__rest)?)),
"BMM_DECLARATION" => ::core::result::Result::Ok(crate::v2_4::bmm3::statement::bmm_statement::BmmStatement::BmmDeclaration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_CALL" => ::core::result::Result::Ok(crate::v2_4::bmm3::statement::bmm_statement::BmmStatement::BmmProcedureCall(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_STATEMENT", __other, "BMM_ACTION_TABLE, BMM_ASSERTION, BMM_ASSIGNMENT, BMM_DECLARATION, BMM_PROCEDURE_CALL")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_STATEMENT",
                            &__other,
                            "BMM_ACTION_TABLE, BMM_ASSERTION, BMM_ASSIGNMENT, BMM_DECLARATION, BMM_PROCEDURE_CALL",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_STATEMENT",
                            "BMM_ACTION_TABLE, BMM_ASSERTION, BMM_ASSIGNMENT, BMM_DECLARATION, BMM_PROCEDURE_CALL",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::statement::bmm_statement_block::BmmStatementBlock {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.items.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_STATEMENT_BLOCK", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_STATEMENT_BLOCK")?;
        if let Some(__v) = &self.items
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "items", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::statement::bmm_statement_block::BmmStatementBlock
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["items"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "items" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_STATEMENT_BLOCK",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::statement::bmm_statement_block::BmmStatementBlock;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_STATEMENT_BLOCK` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_STATEMENT_BLOCK"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("items"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::statement::bmm_statement_block::BmmStatementBlock {
                        items: __s0,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_STATEMENT_BLOCK",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::statement::bmm_statement_item::BmmStatementItem {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm3::statement::bmm_statement_item::BmmStatementItem::BmmActionTable(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::statement::bmm_statement_item::BmmStatementItem::BmmAssertion(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::statement::bmm_statement_item::BmmStatementItem::BmmAssignment(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::statement::bmm_statement_item::BmmStatementItem::BmmDeclaration(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::statement::bmm_statement_item::BmmStatementItem::BmmProcedureCall(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::statement::bmm_statement_item::BmmStatementItem::BmmStatementBlock(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::statement::bmm_statement_item::BmmStatementItem
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_ACTION_TABLE",
            "BMM_ASSERTION",
            "BMM_ASSIGNMENT",
            "BMM_DECLARATION",
            "BMM_PROCEDURE_CALL",
            "BMM_STATEMENT_BLOCK",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::statement::bmm_statement_item::BmmStatementItem;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_STATEMENT_ITEM` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_ACTION_TABLE" => ::core::result::Result::Ok(crate::v2_4::bmm3::statement::bmm_statement_item::BmmStatementItem::BmmActionTable(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ASSERTION" => ::core::result::Result::Ok(crate::v2_4::bmm3::statement::bmm_statement_item::BmmStatementItem::BmmAssertion(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ASSIGNMENT" => ::core::result::Result::Ok(crate::v2_4::bmm3::statement::bmm_statement_item::BmmStatementItem::BmmAssignment(::serde::Deserialize::deserialize(__rest)?)),
"BMM_DECLARATION" => ::core::result::Result::Ok(crate::v2_4::bmm3::statement::bmm_statement_item::BmmStatementItem::BmmDeclaration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_CALL" => ::core::result::Result::Ok(crate::v2_4::bmm3::statement::bmm_statement_item::BmmStatementItem::BmmProcedureCall(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STATEMENT_BLOCK" => ::core::result::Result::Ok(crate::v2_4::bmm3::statement::bmm_statement_item::BmmStatementItem::BmmStatementBlock(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_STATEMENT_ITEM", __other, "BMM_ACTION_TABLE, BMM_ASSERTION, BMM_ASSIGNMENT, BMM_DECLARATION, BMM_PROCEDURE_CALL, BMM_STATEMENT_BLOCK")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_STATEMENT_ITEM",
                            &__other,
                            "BMM_ACTION_TABLE, BMM_ASSERTION, BMM_ASSIGNMENT, BMM_DECLARATION, BMM_PROCEDURE_CALL, BMM_STATEMENT_BLOCK",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_STATEMENT_ITEM",
                            "BMM_ACTION_TABLE, BMM_ASSERTION, BMM_ASSIGNMENT, BMM_DECLARATION, BMM_PROCEDURE_CALL, BMM_STATEMENT_BLOCK",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::feature::bmm_static::BmmStatic {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::core::feature::bmm_static::BmmStatic::BmmConstant(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::feature::bmm_static::BmmStatic::BmmSingleton(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::core::feature::bmm_static::BmmStatic {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_CONSTANT", "BMM_SINGLETON"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::feature::bmm_static::BmmStatic;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_STATIC` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_CONSTANT" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_static::BmmStatic::BmmConstant(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SINGLETON" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_static::BmmStatic::BmmSingleton(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_STATIC", __other, "BMM_CONSTANT, BMM_SINGLETON")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_STATIC",
                            &__other,
                            "BMM_CONSTANT, BMM_SINGLETON",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_STATIC",
                            "BMM_CONSTANT, BMM_SINGLETON",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm3::core::literal_value::bmm_string_value::BmmStringValue
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.syntax.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_STRING_VALUE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_STRING_VALUE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "value_literal",
            &self.value_literal,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "value", &self.value)?;
        if let Some(__v) = &self.syntax {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "syntax", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::literal_value::bmm_string_value::BmmStringValue
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["syntax", "type", "value", "value_literal"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "value_literal" => ::core::result::Result::Ok(__Field::__F0),
                            "value" => ::core::result::Result::Ok(__Field::__F1),
                            "syntax" => ::core::result::Result::Ok(__Field::__F2),
                            "type" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_STRING_VALUE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::literal_value::bmm_string_value::BmmStringValue;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_STRING_VALUE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_STRING_VALUE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value_literal"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("syntax"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::literal_value::bmm_string_value::BmmStringValue {
                        value_literal: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("value_literal"))?,
                        value: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("value"))?,
                        syntax: __s2.flatten(),
                        r#type: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_STRING_VALUE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::entity::bmm_tuple_type::BmmTupleType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_TUPLE_TYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_TUPLE_TYPE")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_types", &self.item_types)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::entity::bmm_tuple_type::BmmTupleType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["item_types"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "item_types" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_TUPLE_TYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::entity::bmm_tuple_type::BmmTupleType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_TUPLE_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_TUPLE_TYPE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_types"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::entity::bmm_tuple_type::BmmTupleType {
                        item_types: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("item_types"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_TUPLE_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_type::BmmType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm::core::bmm_type::BmmType::BmmContainerType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_type::BmmType::BmmGenericType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_type::BmmType::BmmOpenType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_type::BmmType::BmmParameterType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_type::BmmType::BmmSignature(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_type::BmmType::BmmSimpleType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_type::BmmType::BmmStatusType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm::core::bmm_type::BmmType::BmmTupleType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm::core::bmm_type::BmmType {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_CONTAINER_TYPE",
            "BMM_FUNCTION_TYPE",
            "BMM_GENERIC_TYPE",
            "BMM_INDEXED_CONTAINER_TYPE",
            "BMM_OPEN_TYPE",
            "BMM_PARAMETER_TYPE",
            "BMM_PROCEDURE_TYPE",
            "BMM_PROPERTY_TYPE",
            "BMM_ROUTINE_TYPE",
            "BMM_SIGNATURE",
            "BMM_SIMPLE_TYPE",
            "BMM_STATUS_TYPE",
            "BMM_TUPLE_TYPE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_type::BmmType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
                            "BMM_CONTAINER_TYPE" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_type::BmmType::BmmContainerType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_FUNCTION_TYPE" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_type::BmmType::BmmSignature(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_GENERIC_TYPE" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_type::BmmType::BmmGenericType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_type::BmmType::BmmContainerType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_OPEN_TYPE" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_type::BmmType::BmmOpenType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_PARAMETER_TYPE" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_type::BmmType::BmmParameterType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_PROCEDURE_TYPE" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_type::BmmType::BmmSignature(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_PROPERTY_TYPE" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_type::BmmType::BmmSignature(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_ROUTINE_TYPE" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_type::BmmType::BmmSignature(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_SIGNATURE" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_type::BmmType::BmmSignature(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_type::BmmType::BmmSimpleType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_STATUS_TYPE" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_type::BmmType::BmmStatusType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_TUPLE_TYPE" => ::core::result::Result::Ok(
                                crate::v2_4::bmm::core::bmm_type::BmmType::BmmTupleType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            __other => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unexpected_type(
                                    "BMM_TYPE",
                                    __other,
                                    "BMM_CONTAINER_TYPE, BMM_FUNCTION_TYPE, BMM_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_OPEN_TYPE, BMM_PARAMETER_TYPE, BMM_PROCEDURE_TYPE, BMM_PROPERTY_TYPE, BMM_ROUTINE_TYPE, BMM_SIGNATURE, BMM_SIMPLE_TYPE, BMM_STATUS_TYPE, BMM_TUPLE_TYPE",
                                ),
                            ),
                        }
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_TYPE",
                            &__other,
                            "BMM_CONTAINER_TYPE, BMM_FUNCTION_TYPE, BMM_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_OPEN_TYPE, BMM_PARAMETER_TYPE, BMM_PROCEDURE_TYPE, BMM_PROPERTY_TYPE, BMM_ROUTINE_TYPE, BMM_SIGNATURE, BMM_SIMPLE_TYPE, BMM_STATUS_TYPE, BMM_TUPLE_TYPE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_TYPE",
                            "BMM_CONTAINER_TYPE, BMM_FUNCTION_TYPE, BMM_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_OPEN_TYPE, BMM_PARAMETER_TYPE, BMM_PROCEDURE_TYPE, BMM_PROPERTY_TYPE, BMM_ROUTINE_TYPE, BMM_SIGNATURE, BMM_SIMPLE_TYPE, BMM_STATUS_TYPE, BMM_TUPLE_TYPE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::core::bmm_type_element::BmmTypeElement {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm::core::bmm_type_element::BmmTypeElement::BmmGenericParameter(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm::core::bmm_type_element::BmmTypeElement {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_GENERIC_PARAMETER"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::core::bmm_type_element::BmmTypeElement;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_TYPE_ELEMENT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_GENERIC_PARAMETER" => ::core::result::Result::Ok(crate::v2_4::bmm::core::bmm_type_element::BmmTypeElement::BmmGenericParameter(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_TYPE_ELEMENT", __other, "BMM_GENERIC_PARAMETER")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_TYPE_ELEMENT",
                            &__other,
                            "BMM_GENERIC_PARAMETER",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_TYPE_ELEMENT",
                            "BMM_GENERIC_PARAMETER",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm3::core::feature::bmm_unitary_property::BmmUnitaryProperty
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_nullable.is_some() {
            __n += 1;
        }
        if self.is_synthesised_generic.is_some() {
            __n += 1;
        }
        if self
            .feature_extensions
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.is_im_runtime.is_some() {
            __n += 1;
        }
        if self.is_im_infrastructure.is_some() {
            __n += 1;
        }
        if self.is_composition.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_UNITARY_PROPERTY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_UNITARY_PROPERTY")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        if let Some(__v) = &self.is_synthesised_generic {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_synthesised_generic",
                __v,
            )?;
        }
        if let Some(__v) = &self.feature_extensions
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "feature_extensions", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "group", &self.group)?;
        if let Some(__v) = &self.is_im_runtime {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_im_runtime", __v)?;
        }
        if let Some(__v) = &self.is_im_infrastructure {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_im_infrastructure", __v)?;
        }
        if let Some(__v) = &self.is_composition {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_composition", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::feature::bmm_unitary_property::BmmUnitaryProperty
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "documentation",
            "extensions",
            "feature_extensions",
            "group",
            "is_composition",
            "is_im_infrastructure",
            "is_im_runtime",
            "is_nullable",
            "is_synthesised_generic",
            "name",
            "type",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "type" => ::core::result::Result::Ok(__Field::__F3),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F4),
                            "is_synthesised_generic" => ::core::result::Result::Ok(__Field::__F5),
                            "feature_extensions" => ::core::result::Result::Ok(__Field::__F6),
                            "group" => ::core::result::Result::Ok(__Field::__F7),
                            "is_im_runtime" => ::core::result::Result::Ok(__Field::__F8),
                            "is_im_infrastructure" => ::core::result::Result::Ok(__Field::__F9),
                            "is_composition" => ::core::result::Result::Ok(__Field::__F10),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_UNITARY_PROPERTY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::feature::bmm_unitary_property::BmmUnitaryProperty;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_UNITARY_PROPERTY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<_> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("BMM_UNITARY_PROPERTY"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("extensions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_nullable"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_synthesised_generic"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("feature_extensions"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("group"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_im_runtime"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_im_infrastructure"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_composition"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::core::feature::bmm_unitary_property::BmmUnitaryProperty {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s1.flatten(),
                        extensions: __s2.flatten(),
                        r#type: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        is_nullable: __s4.flatten(),
                        is_synthesised_generic: __s5.flatten(),
                        feature_extensions: __s6,
                        group: __s7
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("group"))?,
                        is_im_runtime: __s8.flatten(),
                        is_im_infrastructure: __s9.flatten(),
                        is_composition: __s10.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_UNITARY_PROPERTY",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmGenericType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmParameterType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSignature(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSimpleType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmStatusType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmTupleType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_FUNCTION_TYPE",
            "BMM_GENERIC_TYPE",
            "BMM_PARAMETER_TYPE",
            "BMM_PROCEDURE_TYPE",
            "BMM_PROPERTY_TYPE",
            "BMM_ROUTINE_TYPE",
            "BMM_SIGNATURE",
            "BMM_SIMPLE_TYPE",
            "BMM_STATUS_TYPE",
            "BMM_TUPLE_TYPE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_UNITARY_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_FUNCTION_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PARAMETER_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmParameterType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROPERTY_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ROUTINE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIGNATURE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSimpleType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STATUS_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmStatusType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_TUPLE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmTupleType(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_UNITARY_TYPE", __other, "BMM_FUNCTION_TYPE, BMM_GENERIC_TYPE, BMM_PARAMETER_TYPE, BMM_PROCEDURE_TYPE, BMM_PROPERTY_TYPE, BMM_ROUTINE_TYPE, BMM_SIGNATURE, BMM_SIMPLE_TYPE, BMM_STATUS_TYPE, BMM_TUPLE_TYPE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_UNITARY_TYPE",
                            &__other,
                            "BMM_FUNCTION_TYPE, BMM_GENERIC_TYPE, BMM_PARAMETER_TYPE, BMM_PROCEDURE_TYPE, BMM_PROPERTY_TYPE, BMM_ROUTINE_TYPE, BMM_SIGNATURE, BMM_SIMPLE_TYPE, BMM_STATUS_TYPE, BMM_TUPLE_TYPE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_UNITARY_TYPE",
                            "BMM_FUNCTION_TYPE, BMM_GENERIC_TYPE, BMM_PARAMETER_TYPE, BMM_PROCEDURE_TYPE, BMM_PROPERTY_TYPE, BMM_ROUTINE_TYPE, BMM_SIGNATURE, BMM_SIMPLE_TYPE, BMM_STATUS_TYPE, BMM_TUPLE_TYPE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm3::core::literal_value::bmm_unitary_value::BmmUnitaryValue
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm3::core::literal_value::bmm_unitary_value::BmmUnitaryValue::BmmPrimitiveValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::literal_value::bmm_unitary_value::BmmUnitaryValue
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_BOOLEAN_VALUE",
            "BMM_INTEGER_VALUE",
            "BMM_PRIMITIVE_VALUE",
            "BMM_STRING_VALUE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::literal_value::bmm_unitary_value::BmmUnitaryValue;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_UNITARY_VALUE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_BOOLEAN_VALUE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::literal_value::bmm_unitary_value::BmmUnitaryValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INTEGER_VALUE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::literal_value::bmm_unitary_value::BmmUnitaryValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PRIMITIVE_VALUE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::literal_value::bmm_unitary_value::BmmUnitaryValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STRING_VALUE" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::literal_value::bmm_unitary_value::BmmUnitaryValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_UNITARY_VALUE", __other, "BMM_BOOLEAN_VALUE, BMM_INTEGER_VALUE, BMM_PRIMITIVE_VALUE, BMM_STRING_VALUE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_UNITARY_VALUE",
                            &__other,
                            "BMM_BOOLEAN_VALUE, BMM_INTEGER_VALUE, BMM_PRIMITIVE_VALUE, BMM_STRING_VALUE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_UNITARY_VALUE",
                            "BMM_BOOLEAN_VALUE, BMM_INTEGER_VALUE, BMM_PRIMITIVE_VALUE, BMM_STRING_VALUE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::core::feature::bmm_variable::BmmVariable {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::core::feature::bmm_variable::BmmVariable::BmmLocal(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::feature::bmm_variable::BmmVariable::BmmParameter(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::feature::bmm_variable::BmmVariable::BmmResult(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::core::feature::bmm_variable::BmmVariable::BmmSelf(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::feature::bmm_variable::BmmVariable
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_LOCAL", "BMM_PARAMETER", "BMM_RESULT", "BMM_SELF"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::core::feature::bmm_variable::BmmVariable;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_VARIABLE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_LOCAL" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_variable::BmmVariable::BmmLocal(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PARAMETER" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_variable::BmmVariable::BmmParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_RESULT" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_variable::BmmVariable::BmmResult(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SELF" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_variable::BmmVariable::BmmSelf(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_VARIABLE", __other, "BMM_LOCAL, BMM_PARAMETER, BMM_RESULT, BMM_SELF")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_VARIABLE",
                            &__other,
                            "BMM_LOCAL, BMM_PARAMETER, BMM_RESULT, BMM_SELF",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_VARIABLE",
                            "BMM_LOCAL, BMM_PARAMETER, BMM_RESULT, BMM_SELF",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm3::core::feature::bmm_writable_variable::BmmWritableVariable
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm3::core::feature::bmm_writable_variable::BmmWritableVariable::BmmLocal(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::core::feature::bmm_writable_variable::BmmWritableVariable::BmmResult(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::core::feature::bmm_writable_variable::BmmWritableVariable
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_LOCAL", "BMM_RESULT"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm3::core::feature::bmm_writable_variable::BmmWritableVariable;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_WRITABLE_VARIABLE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_LOCAL" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_writable_variable::BmmWritableVariable::BmmLocal(::serde::Deserialize::deserialize(__rest)?)),
"BMM_RESULT" => ::core::result::Result::Ok(crate::v2_4::bmm3::core::feature::bmm_writable_variable::BmmWritableVariable::BmmResult(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_WRITABLE_VARIABLE", __other, "BMM_LOCAL, BMM_RESULT")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_WRITABLE_VARIABLE",
                            &__other,
                            "BMM_LOCAL, BMM_RESULT",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_WRITABLE_VARIABLE",
                            "BMM_LOCAL, BMM_RESULT",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::constraint_model::primitive::constraint_status::ConstraintStatus
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serializer::serialize_i32(__serializer, self.value())
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::primitive::constraint_status::ConstraintStatus
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        let __v: i32 = ::serde::Deserialize::deserialize(__deserializer)?;
        ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::primitive::constraint_status::ConstraintStatus::from_value(__v))
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::c_archetype_root::CArchetypeRoot {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.parent.is_some() {
            __n += 1;
        }
        if self.soc_parent.is_some() {
            __n += 1;
        }
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self
            .alternative_ids
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.sibling_order.is_some() {
            __n += 1;
        }
        if self.default_value.is_some() {
            __n += 1;
        }
        if self.attributes.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self
            .attribute_tuples
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "C_ARCHETYPE_ROOT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_ARCHETYPE_ROOT")?;
        if let Some(__v) = &self.parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent", __v)?;
        }
        if let Some(__v) = &self.soc_parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "soc_parent", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.alternative_ids
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "alternative_ids", __v)?;
        }
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.sibling_order {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "sibling_order", __v)?;
        }
        if let Some(__v) = &self.default_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "default_value", __v)?;
        }
        if let Some(__v) = &self.attributes
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "attributes", __v)?;
        }
        if let Some(__v) = &self.attribute_tuples
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "attribute_tuples", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "archetype_ref",
            &self.archetype_ref,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::c_archetype_root::CArchetypeRoot
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "alternative_ids",
            "archetype_ref",
            "attribute_tuples",
            "attributes",
            "default_value",
            "is_deprecated",
            "node_id",
            "occurrences",
            "parent",
            "rm_type_name",
            "sibling_order",
            "soc_parent",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent" => ::core::result::Result::Ok(__Field::__F0),
                            "soc_parent" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F2),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F3),
                            "node_id" => ::core::result::Result::Ok(__Field::__F4),
                            "alternative_ids" => ::core::result::Result::Ok(__Field::__F5),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F6),
                            "sibling_order" => ::core::result::Result::Ok(__Field::__F7),
                            "default_value" => ::core::result::Result::Ok(__Field::__F8),
                            "attributes" => ::core::result::Result::Ok(__Field::__F9),
                            "attribute_tuples" => ::core::result::Result::Ok(__Field::__F10),
                            "archetype_ref" => ::core::result::Result::Ok(__Field::__F11),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_ARCHETYPE_ROOT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::c_archetype_root::CArchetypeRoot;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_ARCHETYPE_ROOT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<_> = None;
                let mut __s10: ::core::option::Option<_> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_ARCHETYPE_ROOT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("soc_parent"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("alternative_ids"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("sibling_order"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("default_value"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("attributes"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("attribute_tuples"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("archetype_ref"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::constraint_model::c_archetype_root::CArchetypeRoot {
                        parent: __s0.flatten(),
                        soc_parent: __s1.flatten(),
                        rm_type_name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
                        occurrences: __s3.flatten(),
                        node_id: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
                        alternative_ids: __s5,
                        is_deprecated: __s6.flatten(),
                        sibling_order: __s7.flatten(),
                        default_value: __s8.flatten(),
                        attributes: __s9,
                        attribute_tuples: __s10,
                        archetype_ref: __s11
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("archetype_ref"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "C_ARCHETYPE_ROOT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::c_attribute::CAttribute {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.parent.is_some() {
            __n += 1;
        }
        if self.soc_parent.is_some() {
            __n += 1;
        }
        if self.existence.is_some() {
            __n += 1;
        }
        if self.children.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.differential_path.is_some() {
            __n += 1;
        }
        if self.cardinality.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_ATTRIBUTE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_ATTRIBUTE")?;
        if let Some(__v) = &self.parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent", __v)?;
        }
        if let Some(__v) = &self.soc_parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "soc_parent", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_attribute_name",
            &self.rm_attribute_name,
        )?;
        if let Some(__v) = &self.existence {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "existence", __v)?;
        }
        if let Some(__v) = &self.children
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "children", __v)?;
        }
        if let Some(__v) = &self.differential_path {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "differential_path", __v)?;
        }
        if let Some(__v) = &self.cardinality {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "cardinality", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_multiple",
            &self.is_multiple,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::c_attribute::CAttribute
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "cardinality",
            "children",
            "differential_path",
            "existence",
            "is_multiple",
            "parent",
            "rm_attribute_name",
            "soc_parent",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent" => ::core::result::Result::Ok(__Field::__F0),
                            "soc_parent" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_attribute_name" => ::core::result::Result::Ok(__Field::__F2),
                            "existence" => ::core::result::Result::Ok(__Field::__F3),
                            "children" => ::core::result::Result::Ok(__Field::__F4),
                            "differential_path" => ::core::result::Result::Ok(__Field::__F5),
                            "cardinality" => ::core::result::Result::Ok(__Field::__F6),
                            "is_multiple" => ::core::result::Result::Ok(__Field::__F7),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_ATTRIBUTE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::c_attribute::CAttribute;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_ATTRIBUTE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<_> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_ATTRIBUTE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("soc_parent"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_attribute_name"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("existence"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("children"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("differential_path"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("cardinality"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_multiple"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::constraint_model::c_attribute::CAttribute {
                        parent: __s0.flatten(),
                        soc_parent: __s1.flatten(),
                        rm_attribute_name: __s2.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("rm_attribute_name")
                        })?,
                        existence: __s3.flatten(),
                        children: __s4,
                        differential_path: __s5.flatten(),
                        cardinality: __s6.flatten(),
                        is_multiple: __s7
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_multiple"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "C_ATTRIBUTE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::constraint_model::c_attribute_tuple::CAttributeTuple
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.members.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.tuples.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "C_ATTRIBUTE_TUPLE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_ATTRIBUTE_TUPLE")?;
        if let Some(__v) = &self.members
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "members", __v)?;
        }
        if let Some(__v) = &self.tuples
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "tuples", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::c_attribute_tuple::CAttributeTuple
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["members", "tuples"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "members" => ::core::result::Result::Ok(__Field::__F0),
                            "tuples" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_ATTRIBUTE_TUPLE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::c_attribute_tuple::CAttributeTuple;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_ATTRIBUTE_TUPLE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<_> = None;
                let mut __s1: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_ATTRIBUTE_TUPLE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("members"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("tuples"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::constraint_model::c_attribute_tuple::CAttributeTuple {
                        members: __s0,
                        tuples: __s1,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "C_ATTRIBUTE_TUPLE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::primitive::c_boolean::CBoolean {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.parent.is_some() {
            __n += 1;
        }
        if self.soc_parent.is_some() {
            __n += 1;
        }
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self
            .alternative_ids
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.sibling_order.is_some() {
            __n += 1;
        }
        if self.default_value.is_some() {
            __n += 1;
        }
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.is_enumerated_type_constraint.is_some() {
            __n += 1;
        }
        if self.constraint.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_BOOLEAN", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_BOOLEAN")?;
        if let Some(__v) = &self.parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent", __v)?;
        }
        if let Some(__v) = &self.soc_parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "soc_parent", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.alternative_ids
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "alternative_ids", __v)?;
        }
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.sibling_order {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "sibling_order", __v)?;
        }
        if let Some(__v) = &self.default_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "default_value", __v)?;
        }
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.is_enumerated_type_constraint {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_enumerated_type_constraint",
                __v,
            )?;
        }
        if let Some(__v) = &self.constraint
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constraint", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::primitive::c_boolean::CBoolean
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "alternative_ids",
            "assumed_value",
            "constraint",
            "default_value",
            "is_deprecated",
            "is_enumerated_type_constraint",
            "node_id",
            "occurrences",
            "parent",
            "rm_type_name",
            "sibling_order",
            "soc_parent",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent" => ::core::result::Result::Ok(__Field::__F0),
                            "soc_parent" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F2),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F3),
                            "node_id" => ::core::result::Result::Ok(__Field::__F4),
                            "alternative_ids" => ::core::result::Result::Ok(__Field::__F5),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F6),
                            "sibling_order" => ::core::result::Result::Ok(__Field::__F7),
                            "default_value" => ::core::result::Result::Ok(__Field::__F8),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F9),
                            "is_enumerated_type_constraint" => {
                                ::core::result::Result::Ok(__Field::__F10)
                            }
                            "constraint" => ::core::result::Result::Ok(__Field::__F11),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_BOOLEAN",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::primitive::c_boolean::CBoolean;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_BOOLEAN` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_BOOLEAN"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("soc_parent"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("alternative_ids"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("sibling_order"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("default_value"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "is_enumerated_type_constraint",
                                    ),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constraint"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::constraint_model::primitive::c_boolean::CBoolean {
                        parent: __s0.flatten(),
                        soc_parent: __s1.flatten(),
                        rm_type_name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
                        occurrences: __s3.flatten(),
                        node_id: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
                        alternative_ids: __s5,
                        is_deprecated: __s6.flatten(),
                        sibling_order: __s7.flatten(),
                        default_value: __s8.flatten(),
                        assumed_value: __s9.flatten(),
                        is_enumerated_type_constraint: __s10.flatten(),
                        constraint: __s11,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "C_BOOLEAN", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::constraint_model::c_complex_object::CComplexObjectData
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.parent.is_some() {
            __n += 1;
        }
        if self.soc_parent.is_some() {
            __n += 1;
        }
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self
            .alternative_ids
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.sibling_order.is_some() {
            __n += 1;
        }
        if self.default_value.is_some() {
            __n += 1;
        }
        if self.attributes.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self
            .attribute_tuples
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "C_COMPLEX_OBJECT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_COMPLEX_OBJECT")?;
        if let Some(__v) = &self.parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent", __v)?;
        }
        if let Some(__v) = &self.soc_parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "soc_parent", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.alternative_ids
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "alternative_ids", __v)?;
        }
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.sibling_order {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "sibling_order", __v)?;
        }
        if let Some(__v) = &self.default_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "default_value", __v)?;
        }
        if let Some(__v) = &self.attributes
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "attributes", __v)?;
        }
        if let Some(__v) = &self.attribute_tuples
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "attribute_tuples", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::c_complex_object::CComplexObjectData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "alternative_ids",
            "attribute_tuples",
            "attributes",
            "default_value",
            "is_deprecated",
            "node_id",
            "occurrences",
            "parent",
            "rm_type_name",
            "sibling_order",
            "soc_parent",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent" => ::core::result::Result::Ok(__Field::__F0),
                            "soc_parent" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F2),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F3),
                            "node_id" => ::core::result::Result::Ok(__Field::__F4),
                            "alternative_ids" => ::core::result::Result::Ok(__Field::__F5),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F6),
                            "sibling_order" => ::core::result::Result::Ok(__Field::__F7),
                            "default_value" => ::core::result::Result::Ok(__Field::__F8),
                            "attributes" => ::core::result::Result::Ok(__Field::__F9),
                            "attribute_tuples" => ::core::result::Result::Ok(__Field::__F10),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_COMPLEX_OBJECT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::c_complex_object::CComplexObjectData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_COMPLEX_OBJECT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<_> = None;
                let mut __s10: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_COMPLEX_OBJECT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("soc_parent"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("alternative_ids"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("sibling_order"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("default_value"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("attributes"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("attribute_tuples"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::constraint_model::c_complex_object::CComplexObjectData {
                        parent: __s0.flatten(),
                        soc_parent: __s1.flatten(),
                        rm_type_name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
                        occurrences: __s3.flatten(),
                        node_id: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
                        alternative_ids: __s5,
                        is_deprecated: __s6.flatten(),
                        sibling_order: __s7.flatten(),
                        default_value: __s8.flatten(),
                        attributes: __s9,
                        attribute_tuples: __s10,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "C_COMPLEX_OBJECT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::c_complex_object::CComplexObject {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::aom2::constraint_model::c_complex_object::CComplexObject::CArchetypeRoot(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_complex_object::CComplexObject::CComplexObject(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::c_complex_object::CComplexObject
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["C_ARCHETYPE_ROOT", "C_COMPLEX_OBJECT"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::c_complex_object::CComplexObject;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_COMPLEX_OBJECT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"C_ARCHETYPE_ROOT" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_complex_object::CComplexObject::CArchetypeRoot(::serde::Deserialize::deserialize(__rest)?)),
"C_COMPLEX_OBJECT" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_complex_object::CComplexObject::CComplexObject(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("C_COMPLEX_OBJECT", __other, "C_ARCHETYPE_ROOT, C_COMPLEX_OBJECT")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "C_COMPLEX_OBJECT",
                            &__other,
                            "C_ARCHETYPE_ROOT, C_COMPLEX_OBJECT",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_complex_object::CComplexObject::CComplexObject(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::constraint_model::c_complex_object_proxy::CComplexObjectProxy
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.parent.is_some() {
            __n += 1;
        }
        if self.soc_parent.is_some() {
            __n += 1;
        }
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self
            .alternative_ids
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.sibling_order.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "C_COMPLEX_OBJECT_PROXY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "C_COMPLEX_OBJECT_PROXY",
        )?;
        if let Some(__v) = &self.parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent", __v)?;
        }
        if let Some(__v) = &self.soc_parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "soc_parent", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.alternative_ids
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "alternative_ids", __v)?;
        }
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.sibling_order {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "sibling_order", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "target_path",
            &self.target_path,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::c_complex_object_proxy::CComplexObjectProxy
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "alternative_ids",
            "is_deprecated",
            "node_id",
            "occurrences",
            "parent",
            "rm_type_name",
            "sibling_order",
            "soc_parent",
            "target_path",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent" => ::core::result::Result::Ok(__Field::__F0),
                            "soc_parent" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F2),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F3),
                            "node_id" => ::core::result::Result::Ok(__Field::__F4),
                            "alternative_ids" => ::core::result::Result::Ok(__Field::__F5),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F6),
                            "sibling_order" => ::core::result::Result::Ok(__Field::__F7),
                            "target_path" => ::core::result::Result::Ok(__Field::__F8),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_COMPLEX_OBJECT_PROXY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::aom2::constraint_model::c_complex_object_proxy::CComplexObjectProxy;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_COMPLEX_OBJECT_PROXY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "C_COMPLEX_OBJECT_PROXY",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("soc_parent"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("alternative_ids"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("sibling_order"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("target_path"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_complex_object_proxy::CComplexObjectProxy {
parent: __s0.flatten(),
soc_parent: __s1.flatten(),
rm_type_name: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
occurrences: __s3.flatten(),
node_id: __s4.flatten().ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
alternative_ids: __s5,
is_deprecated: __s6.flatten(),
sibling_order: __s7.flatten(),
target_path: __s8.flatten().ok_or_else(|| ::serde::de::Error::missing_field("target_path"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "C_COMPLEX_OBJECT_PROXY",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::primitive::c_date::CDate {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.parent.is_some() {
            __n += 1;
        }
        if self.soc_parent.is_some() {
            __n += 1;
        }
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self
            .alternative_ids
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.sibling_order.is_some() {
            __n += 1;
        }
        if self.default_value.is_some() {
            __n += 1;
        }
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.is_enumerated_type_constraint.is_some() {
            __n += 1;
        }
        if self.constraint.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.pattern_constraint.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_DATE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_DATE")?;
        if let Some(__v) = &self.parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent", __v)?;
        }
        if let Some(__v) = &self.soc_parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "soc_parent", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.alternative_ids
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "alternative_ids", __v)?;
        }
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.sibling_order {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "sibling_order", __v)?;
        }
        if let Some(__v) = &self.default_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "default_value", __v)?;
        }
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.is_enumerated_type_constraint {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_enumerated_type_constraint",
                __v,
            )?;
        }
        if let Some(__v) = &self.constraint
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constraint", __v)?;
        }
        if let Some(__v) = &self.pattern_constraint {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "pattern_constraint", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::primitive::c_date::CDate
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "alternative_ids",
            "assumed_value",
            "constraint",
            "default_value",
            "is_deprecated",
            "is_enumerated_type_constraint",
            "node_id",
            "occurrences",
            "parent",
            "pattern_constraint",
            "rm_type_name",
            "sibling_order",
            "soc_parent",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent" => ::core::result::Result::Ok(__Field::__F0),
                            "soc_parent" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F2),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F3),
                            "node_id" => ::core::result::Result::Ok(__Field::__F4),
                            "alternative_ids" => ::core::result::Result::Ok(__Field::__F5),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F6),
                            "sibling_order" => ::core::result::Result::Ok(__Field::__F7),
                            "default_value" => ::core::result::Result::Ok(__Field::__F8),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F9),
                            "is_enumerated_type_constraint" => {
                                ::core::result::Result::Ok(__Field::__F10)
                            }
                            "constraint" => ::core::result::Result::Ok(__Field::__F11),
                            "pattern_constraint" => ::core::result::Result::Ok(__Field::__F12),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v, "C_DATE", __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::primitive::c_date::CDate;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_DATE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<_> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_DATE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("soc_parent"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("alternative_ids"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("sibling_order"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("default_value"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "is_enumerated_type_constraint",
                                    ),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constraint"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("pattern_constraint"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::constraint_model::primitive::c_date::CDate {
                        parent: __s0.flatten(),
                        soc_parent: __s1.flatten(),
                        rm_type_name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
                        occurrences: __s3.flatten(),
                        node_id: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
                        alternative_ids: __s5,
                        is_deprecated: __s6.flatten(),
                        sibling_order: __s7.flatten(),
                        default_value: __s8.flatten(),
                        assumed_value: __s9.flatten(),
                        is_enumerated_type_constraint: __s10.flatten(),
                        constraint: __s11,
                        pattern_constraint: __s12.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "C_DATE", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::primitive::c_date_time::CDateTime {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.parent.is_some() {
            __n += 1;
        }
        if self.soc_parent.is_some() {
            __n += 1;
        }
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self
            .alternative_ids
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.sibling_order.is_some() {
            __n += 1;
        }
        if self.default_value.is_some() {
            __n += 1;
        }
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.is_enumerated_type_constraint.is_some() {
            __n += 1;
        }
        if self.constraint.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.pattern_constraint.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_DATE_TIME", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_DATE_TIME")?;
        if let Some(__v) = &self.parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent", __v)?;
        }
        if let Some(__v) = &self.soc_parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "soc_parent", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.alternative_ids
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "alternative_ids", __v)?;
        }
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.sibling_order {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "sibling_order", __v)?;
        }
        if let Some(__v) = &self.default_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "default_value", __v)?;
        }
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.is_enumerated_type_constraint {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_enumerated_type_constraint",
                __v,
            )?;
        }
        if let Some(__v) = &self.constraint
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constraint", __v)?;
        }
        if let Some(__v) = &self.pattern_constraint {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "pattern_constraint", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::primitive::c_date_time::CDateTime
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "alternative_ids",
            "assumed_value",
            "constraint",
            "default_value",
            "is_deprecated",
            "is_enumerated_type_constraint",
            "node_id",
            "occurrences",
            "parent",
            "pattern_constraint",
            "rm_type_name",
            "sibling_order",
            "soc_parent",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent" => ::core::result::Result::Ok(__Field::__F0),
                            "soc_parent" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F2),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F3),
                            "node_id" => ::core::result::Result::Ok(__Field::__F4),
                            "alternative_ids" => ::core::result::Result::Ok(__Field::__F5),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F6),
                            "sibling_order" => ::core::result::Result::Ok(__Field::__F7),
                            "default_value" => ::core::result::Result::Ok(__Field::__F8),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F9),
                            "is_enumerated_type_constraint" => {
                                ::core::result::Result::Ok(__Field::__F10)
                            }
                            "constraint" => ::core::result::Result::Ok(__Field::__F11),
                            "pattern_constraint" => ::core::result::Result::Ok(__Field::__F12),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_DATE_TIME",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::primitive::c_date_time::CDateTime;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_DATE_TIME` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<_> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_DATE_TIME"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("soc_parent"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("alternative_ids"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("sibling_order"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("default_value"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "is_enumerated_type_constraint",
                                    ),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constraint"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("pattern_constraint"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::constraint_model::primitive::c_date_time::CDateTime {
                        parent: __s0.flatten(),
                        soc_parent: __s1.flatten(),
                        rm_type_name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
                        occurrences: __s3.flatten(),
                        node_id: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
                        alternative_ids: __s5,
                        is_deprecated: __s6.flatten(),
                        sibling_order: __s7.flatten(),
                        default_value: __s8.flatten(),
                        assumed_value: __s9.flatten(),
                        is_enumerated_type_constraint: __s10.flatten(),
                        constraint: __s11,
                        pattern_constraint: __s12.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "C_DATE_TIME",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CBoolean(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CComplexObject(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CDate(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CDateTime(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CDuration(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CInteger(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CReal(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CString(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CTerminologyCode(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CTime(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "C_ARCHETYPE_ROOT",
            "C_BOOLEAN",
            "C_COMPLEX_OBJECT",
            "C_DATE",
            "C_DATE_TIME",
            "C_DURATION",
            "C_INTEGER",
            "C_REAL",
            "C_STRING",
            "C_TERMINOLOGY_CODE",
            "C_TIME",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_DEFINED_OBJECT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"C_ARCHETYPE_ROOT" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CComplexObject(::serde::Deserialize::deserialize(__rest)?)),
"C_BOOLEAN" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CBoolean(::serde::Deserialize::deserialize(__rest)?)),
"C_COMPLEX_OBJECT" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CComplexObject(::serde::Deserialize::deserialize(__rest)?)),
"C_DATE" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CDate(::serde::Deserialize::deserialize(__rest)?)),
"C_DATE_TIME" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CDateTime(::serde::Deserialize::deserialize(__rest)?)),
"C_DURATION" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CDuration(::serde::Deserialize::deserialize(__rest)?)),
"C_INTEGER" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CInteger(::serde::Deserialize::deserialize(__rest)?)),
"C_REAL" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CReal(::serde::Deserialize::deserialize(__rest)?)),
"C_STRING" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CString(::serde::Deserialize::deserialize(__rest)?)),
"C_TERMINOLOGY_CODE" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CTerminologyCode(::serde::Deserialize::deserialize(__rest)?)),
"C_TIME" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_defined_object::CDefinedObject::CTime(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("C_DEFINED_OBJECT", __other, "C_ARCHETYPE_ROOT, C_BOOLEAN, C_COMPLEX_OBJECT, C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_STRING, C_TERMINOLOGY_CODE, C_TIME")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "C_DEFINED_OBJECT",
                            &__other,
                            "C_ARCHETYPE_ROOT, C_BOOLEAN, C_COMPLEX_OBJECT, C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_STRING, C_TERMINOLOGY_CODE, C_TIME",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "C_DEFINED_OBJECT",
                            "C_ARCHETYPE_ROOT, C_BOOLEAN, C_COMPLEX_OBJECT, C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_STRING, C_TERMINOLOGY_CODE, C_TIME",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::primitive::c_duration::CDuration {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.parent.is_some() {
            __n += 1;
        }
        if self.soc_parent.is_some() {
            __n += 1;
        }
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self
            .alternative_ids
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.sibling_order.is_some() {
            __n += 1;
        }
        if self.default_value.is_some() {
            __n += 1;
        }
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.is_enumerated_type_constraint.is_some() {
            __n += 1;
        }
        if self.constraint.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.pattern_constraint.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_DURATION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_DURATION")?;
        if let Some(__v) = &self.parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent", __v)?;
        }
        if let Some(__v) = &self.soc_parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "soc_parent", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.alternative_ids
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "alternative_ids", __v)?;
        }
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.sibling_order {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "sibling_order", __v)?;
        }
        if let Some(__v) = &self.default_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "default_value", __v)?;
        }
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.is_enumerated_type_constraint {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_enumerated_type_constraint",
                __v,
            )?;
        }
        if let Some(__v) = &self.constraint
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constraint", __v)?;
        }
        if let Some(__v) = &self.pattern_constraint {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "pattern_constraint", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::primitive::c_duration::CDuration
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "alternative_ids",
            "assumed_value",
            "constraint",
            "default_value",
            "is_deprecated",
            "is_enumerated_type_constraint",
            "node_id",
            "occurrences",
            "parent",
            "pattern_constraint",
            "rm_type_name",
            "sibling_order",
            "soc_parent",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent" => ::core::result::Result::Ok(__Field::__F0),
                            "soc_parent" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F2),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F3),
                            "node_id" => ::core::result::Result::Ok(__Field::__F4),
                            "alternative_ids" => ::core::result::Result::Ok(__Field::__F5),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F6),
                            "sibling_order" => ::core::result::Result::Ok(__Field::__F7),
                            "default_value" => ::core::result::Result::Ok(__Field::__F8),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F9),
                            "is_enumerated_type_constraint" => {
                                ::core::result::Result::Ok(__Field::__F10)
                            }
                            "constraint" => ::core::result::Result::Ok(__Field::__F11),
                            "pattern_constraint" => ::core::result::Result::Ok(__Field::__F12),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_DURATION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::primitive::c_duration::CDuration;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_DURATION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<_> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_DURATION"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("soc_parent"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("alternative_ids"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("sibling_order"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("default_value"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "is_enumerated_type_constraint",
                                    ),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constraint"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("pattern_constraint"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::constraint_model::primitive::c_duration::CDuration {
                        parent: __s0.flatten(),
                        soc_parent: __s1.flatten(),
                        rm_type_name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
                        occurrences: __s3.flatten(),
                        node_id: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
                        alternative_ids: __s5,
                        is_deprecated: __s6.flatten(),
                        sibling_order: __s7.flatten(),
                        default_value: __s8.flatten(),
                        assumed_value: __s9.flatten(),
                        is_enumerated_type_constraint: __s10.flatten(),
                        constraint: __s11,
                        pattern_constraint: __s12.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "C_DURATION", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::primitive::c_integer::CInteger {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.parent.is_some() {
            __n += 1;
        }
        if self.soc_parent.is_some() {
            __n += 1;
        }
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self
            .alternative_ids
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.sibling_order.is_some() {
            __n += 1;
        }
        if self.default_value.is_some() {
            __n += 1;
        }
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.is_enumerated_type_constraint.is_some() {
            __n += 1;
        }
        if self.constraint.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_INTEGER", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_INTEGER")?;
        if let Some(__v) = &self.parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent", __v)?;
        }
        if let Some(__v) = &self.soc_parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "soc_parent", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.alternative_ids
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "alternative_ids", __v)?;
        }
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.sibling_order {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "sibling_order", __v)?;
        }
        if let Some(__v) = &self.default_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "default_value", __v)?;
        }
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.is_enumerated_type_constraint {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_enumerated_type_constraint",
                __v,
            )?;
        }
        if let Some(__v) = &self.constraint
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constraint", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::primitive::c_integer::CInteger
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "alternative_ids",
            "assumed_value",
            "constraint",
            "default_value",
            "is_deprecated",
            "is_enumerated_type_constraint",
            "node_id",
            "occurrences",
            "parent",
            "rm_type_name",
            "sibling_order",
            "soc_parent",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent" => ::core::result::Result::Ok(__Field::__F0),
                            "soc_parent" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F2),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F3),
                            "node_id" => ::core::result::Result::Ok(__Field::__F4),
                            "alternative_ids" => ::core::result::Result::Ok(__Field::__F5),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F6),
                            "sibling_order" => ::core::result::Result::Ok(__Field::__F7),
                            "default_value" => ::core::result::Result::Ok(__Field::__F8),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F9),
                            "is_enumerated_type_constraint" => {
                                ::core::result::Result::Ok(__Field::__F10)
                            }
                            "constraint" => ::core::result::Result::Ok(__Field::__F11),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_INTEGER",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::primitive::c_integer::CInteger;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_INTEGER` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_INTEGER"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("soc_parent"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("alternative_ids"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("sibling_order"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("default_value"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "is_enumerated_type_constraint",
                                    ),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constraint"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::constraint_model::primitive::c_integer::CInteger {
                        parent: __s0.flatten(),
                        soc_parent: __s1.flatten(),
                        rm_type_name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
                        occurrences: __s3.flatten(),
                        node_id: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
                        alternative_ids: __s5,
                        is_deprecated: __s6.flatten(),
                        sibling_order: __s7.flatten(),
                        default_value: __s8.flatten(),
                        assumed_value: __s9.flatten(),
                        is_enumerated_type_constraint: __s10.flatten(),
                        constraint: __s11,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "C_INTEGER", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::c_object::CObject {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::aom2::constraint_model::c_object::CObject::ArchetypeSlot(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::constraint_model::c_object::CObject::CBoolean(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::constraint_model::c_object::CObject::CComplexObject(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::constraint_model::c_object::CObject::CComplexObjectProxy(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::constraint_model::c_object::CObject::CDate(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::constraint_model::c_object::CObject::CDateTime(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::constraint_model::c_object::CObject::CDuration(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::constraint_model::c_object::CObject::CInteger(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::constraint_model::c_object::CObject::CReal(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::constraint_model::c_object::CObject::CString(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::constraint_model::c_object::CObject::CTerminologyCode(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::constraint_model::c_object::CObject::CTime(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::aom2::constraint_model::c_object::CObject {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "ARCHETYPE_SLOT",
            "C_ARCHETYPE_ROOT",
            "C_BOOLEAN",
            "C_COMPLEX_OBJECT",
            "C_COMPLEX_OBJECT_PROXY",
            "C_DATE",
            "C_DATE_TIME",
            "C_DURATION",
            "C_INTEGER",
            "C_REAL",
            "C_STRING",
            "C_TERMINOLOGY_CODE",
            "C_TIME",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::c_object::CObject;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_OBJECT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"ARCHETYPE_SLOT" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_object::CObject::ArchetypeSlot(::serde::Deserialize::deserialize(__rest)?)),
"C_ARCHETYPE_ROOT" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_object::CObject::CComplexObject(::serde::Deserialize::deserialize(__rest)?)),
"C_BOOLEAN" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_object::CObject::CBoolean(::serde::Deserialize::deserialize(__rest)?)),
"C_COMPLEX_OBJECT" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_object::CObject::CComplexObject(::serde::Deserialize::deserialize(__rest)?)),
"C_COMPLEX_OBJECT_PROXY" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_object::CObject::CComplexObjectProxy(::serde::Deserialize::deserialize(__rest)?)),
"C_DATE" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_object::CObject::CDate(::serde::Deserialize::deserialize(__rest)?)),
"C_DATE_TIME" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_object::CObject::CDateTime(::serde::Deserialize::deserialize(__rest)?)),
"C_DURATION" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_object::CObject::CDuration(::serde::Deserialize::deserialize(__rest)?)),
"C_INTEGER" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_object::CObject::CInteger(::serde::Deserialize::deserialize(__rest)?)),
"C_REAL" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_object::CObject::CReal(::serde::Deserialize::deserialize(__rest)?)),
"C_STRING" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_object::CObject::CString(::serde::Deserialize::deserialize(__rest)?)),
"C_TERMINOLOGY_CODE" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_object::CObject::CTerminologyCode(::serde::Deserialize::deserialize(__rest)?)),
"C_TIME" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_object::CObject::CTime(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("C_OBJECT", __other, "ARCHETYPE_SLOT, C_ARCHETYPE_ROOT, C_BOOLEAN, C_COMPLEX_OBJECT, C_COMPLEX_OBJECT_PROXY, C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_STRING, C_TERMINOLOGY_CODE, C_TIME")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "C_OBJECT",
                            &__other,
                            "ARCHETYPE_SLOT, C_ARCHETYPE_ROOT, C_BOOLEAN, C_COMPLEX_OBJECT, C_COMPLEX_OBJECT_PROXY, C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_STRING, C_TERMINOLOGY_CODE, C_TIME",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "C_OBJECT",
                            "ARCHETYPE_SLOT, C_ARCHETYPE_ROOT, C_BOOLEAN, C_COMPLEX_OBJECT, C_COMPLEX_OBJECT_PROXY, C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_STRING, C_TERMINOLOGY_CODE, C_TIME",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::primitive::c_ordered::COrdered {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::aom2::constraint_model::primitive::c_ordered::COrdered::CDate(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::constraint_model::primitive::c_ordered::COrdered::CDateTime(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::constraint_model::primitive::c_ordered::COrdered::CDuration(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::constraint_model::primitive::c_ordered::COrdered::CInteger(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::constraint_model::primitive::c_ordered::COrdered::CReal(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::constraint_model::primitive::c_ordered::COrdered::CTime(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::primitive::c_ordered::COrdered
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "C_DATE",
            "C_DATE_TIME",
            "C_DURATION",
            "C_INTEGER",
            "C_REAL",
            "C_TIME",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::primitive::c_ordered::COrdered;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_ORDERED` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"C_DATE" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::primitive::c_ordered::COrdered::CDate(::serde::Deserialize::deserialize(__rest)?)),
"C_DATE_TIME" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::primitive::c_ordered::COrdered::CDateTime(::serde::Deserialize::deserialize(__rest)?)),
"C_DURATION" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::primitive::c_ordered::COrdered::CDuration(::serde::Deserialize::deserialize(__rest)?)),
"C_INTEGER" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::primitive::c_ordered::COrdered::CInteger(::serde::Deserialize::deserialize(__rest)?)),
"C_REAL" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::primitive::c_ordered::COrdered::CReal(::serde::Deserialize::deserialize(__rest)?)),
"C_TIME" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::primitive::c_ordered::COrdered::CTime(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("C_ORDERED", __other, "C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_TIME")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "C_ORDERED",
                            &__other,
                            "C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_TIME",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "C_ORDERED",
                            "C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_TIME",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CBoolean(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CDate(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CDateTime(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CDuration(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CInteger(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CReal(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CString(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CTerminologyCode(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CTime(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "C_BOOLEAN",
            "C_DATE",
            "C_DATE_TIME",
            "C_DURATION",
            "C_INTEGER",
            "C_REAL",
            "C_STRING",
            "C_TERMINOLOGY_CODE",
            "C_TIME",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_PRIMITIVE_OBJECT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"C_BOOLEAN" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CBoolean(::serde::Deserialize::deserialize(__rest)?)),
"C_DATE" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CDate(::serde::Deserialize::deserialize(__rest)?)),
"C_DATE_TIME" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CDateTime(::serde::Deserialize::deserialize(__rest)?)),
"C_DURATION" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CDuration(::serde::Deserialize::deserialize(__rest)?)),
"C_INTEGER" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CInteger(::serde::Deserialize::deserialize(__rest)?)),
"C_REAL" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CReal(::serde::Deserialize::deserialize(__rest)?)),
"C_STRING" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CString(::serde::Deserialize::deserialize(__rest)?)),
"C_TERMINOLOGY_CODE" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CTerminologyCode(::serde::Deserialize::deserialize(__rest)?)),
"C_TIME" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_primitive_object::CPrimitiveObject::CTime(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("C_PRIMITIVE_OBJECT", __other, "C_BOOLEAN, C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_STRING, C_TERMINOLOGY_CODE, C_TIME")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "C_PRIMITIVE_OBJECT",
                            &__other,
                            "C_BOOLEAN, C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_STRING, C_TERMINOLOGY_CODE, C_TIME",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "C_PRIMITIVE_OBJECT",
                            "C_BOOLEAN, C_DATE, C_DATE_TIME, C_DURATION, C_INTEGER, C_REAL, C_STRING, C_TERMINOLOGY_CODE, C_TIME",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::constraint_model::c_primitive_tuple::CPrimitiveTuple
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "C_PRIMITIVE_TUPLE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_PRIMITIVE_TUPLE")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "members", &self.members)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::c_primitive_tuple::CPrimitiveTuple
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["members"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "members" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_PRIMITIVE_TUPLE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::c_primitive_tuple::CPrimitiveTuple;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_PRIMITIVE_TUPLE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_PRIMITIVE_TUPLE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("members"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::constraint_model::c_primitive_tuple::CPrimitiveTuple {
                        members: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("members"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "C_PRIMITIVE_TUPLE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::primitive::c_real::CReal {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.parent.is_some() {
            __n += 1;
        }
        if self.soc_parent.is_some() {
            __n += 1;
        }
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self
            .alternative_ids
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.sibling_order.is_some() {
            __n += 1;
        }
        if self.default_value.is_some() {
            __n += 1;
        }
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.is_enumerated_type_constraint.is_some() {
            __n += 1;
        }
        if self.constraint.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_REAL", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_REAL")?;
        if let Some(__v) = &self.parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent", __v)?;
        }
        if let Some(__v) = &self.soc_parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "soc_parent", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.alternative_ids
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "alternative_ids", __v)?;
        }
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.sibling_order {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "sibling_order", __v)?;
        }
        if let Some(__v) = &self.default_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "default_value", __v)?;
        }
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.is_enumerated_type_constraint {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_enumerated_type_constraint",
                __v,
            )?;
        }
        if let Some(__v) = &self.constraint
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constraint", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::primitive::c_real::CReal
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "alternative_ids",
            "assumed_value",
            "constraint",
            "default_value",
            "is_deprecated",
            "is_enumerated_type_constraint",
            "node_id",
            "occurrences",
            "parent",
            "rm_type_name",
            "sibling_order",
            "soc_parent",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent" => ::core::result::Result::Ok(__Field::__F0),
                            "soc_parent" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F2),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F3),
                            "node_id" => ::core::result::Result::Ok(__Field::__F4),
                            "alternative_ids" => ::core::result::Result::Ok(__Field::__F5),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F6),
                            "sibling_order" => ::core::result::Result::Ok(__Field::__F7),
                            "default_value" => ::core::result::Result::Ok(__Field::__F8),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F9),
                            "is_enumerated_type_constraint" => {
                                ::core::result::Result::Ok(__Field::__F10)
                            }
                            "constraint" => ::core::result::Result::Ok(__Field::__F11),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v, "C_REAL", __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::primitive::c_real::CReal;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_REAL` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_REAL"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("soc_parent"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("alternative_ids"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("sibling_order"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("default_value"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "is_enumerated_type_constraint",
                                    ),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constraint"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::constraint_model::primitive::c_real::CReal {
                        parent: __s0.flatten(),
                        soc_parent: __s1.flatten(),
                        rm_type_name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
                        occurrences: __s3.flatten(),
                        node_id: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
                        alternative_ids: __s5,
                        is_deprecated: __s6.flatten(),
                        sibling_order: __s7.flatten(),
                        default_value: __s8.flatten(),
                        assumed_value: __s9.flatten(),
                        is_enumerated_type_constraint: __s10.flatten(),
                        constraint: __s11,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "C_REAL", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::c_second_order::CSecondOrder {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::aom2::constraint_model::c_second_order::CSecondOrder::CAttributeTuple(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::aom2::constraint_model::c_second_order::CSecondOrder::CPrimitiveTuple(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::c_second_order::CSecondOrder
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["C_ATTRIBUTE_TUPLE", "C_PRIMITIVE_TUPLE"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::c_second_order::CSecondOrder;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_SECOND_ORDER` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"C_ATTRIBUTE_TUPLE" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_second_order::CSecondOrder::CAttributeTuple(::serde::Deserialize::deserialize(__rest)?)),
"C_PRIMITIVE_TUPLE" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::c_second_order::CSecondOrder::CPrimitiveTuple(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("C_SECOND_ORDER", __other, "C_ATTRIBUTE_TUPLE, C_PRIMITIVE_TUPLE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "C_SECOND_ORDER",
                            &__other,
                            "C_ATTRIBUTE_TUPLE, C_PRIMITIVE_TUPLE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "C_SECOND_ORDER",
                            "C_ATTRIBUTE_TUPLE, C_PRIMITIVE_TUPLE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::primitive::c_string::CString {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.parent.is_some() {
            __n += 1;
        }
        if self.soc_parent.is_some() {
            __n += 1;
        }
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self
            .alternative_ids
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.sibling_order.is_some() {
            __n += 1;
        }
        if self.default_value.is_some() {
            __n += 1;
        }
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.is_enumerated_type_constraint.is_some() {
            __n += 1;
        }
        if self.constraint.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_STRING", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_STRING")?;
        if let Some(__v) = &self.parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent", __v)?;
        }
        if let Some(__v) = &self.soc_parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "soc_parent", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.alternative_ids
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "alternative_ids", __v)?;
        }
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.sibling_order {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "sibling_order", __v)?;
        }
        if let Some(__v) = &self.default_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "default_value", __v)?;
        }
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.is_enumerated_type_constraint {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_enumerated_type_constraint",
                __v,
            )?;
        }
        if let Some(__v) = &self.constraint
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constraint", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::primitive::c_string::CString
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "alternative_ids",
            "assumed_value",
            "constraint",
            "default_value",
            "is_deprecated",
            "is_enumerated_type_constraint",
            "node_id",
            "occurrences",
            "parent",
            "rm_type_name",
            "sibling_order",
            "soc_parent",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent" => ::core::result::Result::Ok(__Field::__F0),
                            "soc_parent" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F2),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F3),
                            "node_id" => ::core::result::Result::Ok(__Field::__F4),
                            "alternative_ids" => ::core::result::Result::Ok(__Field::__F5),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F6),
                            "sibling_order" => ::core::result::Result::Ok(__Field::__F7),
                            "default_value" => ::core::result::Result::Ok(__Field::__F8),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F9),
                            "is_enumerated_type_constraint" => {
                                ::core::result::Result::Ok(__Field::__F10)
                            }
                            "constraint" => ::core::result::Result::Ok(__Field::__F11),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v, "C_STRING", __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::primitive::c_string::CString;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_STRING` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_STRING"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("soc_parent"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("alternative_ids"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("sibling_order"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("default_value"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "is_enumerated_type_constraint",
                                    ),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constraint"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::constraint_model::primitive::c_string::CString {
                        parent: __s0.flatten(),
                        soc_parent: __s1.flatten(),
                        rm_type_name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
                        occurrences: __s3.flatten(),
                        node_id: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
                        alternative_ids: __s5,
                        is_deprecated: __s6.flatten(),
                        sibling_order: __s7.flatten(),
                        default_value: __s8.flatten(),
                        assumed_value: __s9.flatten(),
                        is_enumerated_type_constraint: __s10.flatten(),
                        constraint: __s11,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "C_STRING", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::primitive::c_temporal::CTemporal {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::aom2::constraint_model::primitive::c_temporal::CTemporal::CDate(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::aom2::constraint_model::primitive::c_temporal::CTemporal::CDateTime(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::aom2::constraint_model::primitive::c_temporal::CTemporal::CDuration(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::aom2::constraint_model::primitive::c_temporal::CTemporal::CTime(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::primitive::c_temporal::CTemporal
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["C_DATE", "C_DATE_TIME", "C_DURATION", "C_TIME"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::primitive::c_temporal::CTemporal;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_TEMPORAL` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"C_DATE" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::primitive::c_temporal::CTemporal::CDate(::serde::Deserialize::deserialize(__rest)?)),
"C_DATE_TIME" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::primitive::c_temporal::CTemporal::CDateTime(::serde::Deserialize::deserialize(__rest)?)),
"C_DURATION" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::primitive::c_temporal::CTemporal::CDuration(::serde::Deserialize::deserialize(__rest)?)),
"C_TIME" => ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::primitive::c_temporal::CTemporal::CTime(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("C_TEMPORAL", __other, "C_DATE, C_DATE_TIME, C_DURATION, C_TIME")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "C_TEMPORAL",
                            &__other,
                            "C_DATE, C_DATE_TIME, C_DURATION, C_TIME",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "C_TEMPORAL",
                            "C_DATE, C_DATE_TIME, C_DURATION, C_TIME",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::constraint_model::primitive::c_temporal_definitions::CTemporalDefinitions
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 7usize;
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "C_TEMPORAL_DEFINITIONS", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "C_TEMPORAL_DEFINITIONS",
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "valid_date_constraint_patterns",
            &self.valid_date_constraint_patterns,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "valid_date_constraint_replacements",
            &self.valid_date_constraint_replacements,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "valid_time_constraint_patterns",
            &self.valid_time_constraint_patterns,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "valid_time_constraint_replacements",
            &self.valid_time_constraint_replacements,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "valid_date_time_constraint_patterns",
            &self.valid_date_time_constraint_patterns,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "valid_date_time_constraint_replacements",
            &self.valid_date_time_constraint_replacements,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::primitive::c_temporal_definitions::CTemporalDefinitions
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "valid_date_constraint_patterns",
            "valid_date_constraint_replacements",
            "valid_date_time_constraint_patterns",
            "valid_date_time_constraint_replacements",
            "valid_time_constraint_patterns",
            "valid_time_constraint_replacements",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "valid_date_constraint_patterns" => {
                                ::core::result::Result::Ok(__Field::__F0)
                            }
                            "valid_date_constraint_replacements" => {
                                ::core::result::Result::Ok(__Field::__F1)
                            }
                            "valid_time_constraint_patterns" => {
                                ::core::result::Result::Ok(__Field::__F2)
                            }
                            "valid_time_constraint_replacements" => {
                                ::core::result::Result::Ok(__Field::__F3)
                            }
                            "valid_date_time_constraint_patterns" => {
                                ::core::result::Result::Ok(__Field::__F4)
                            }
                            "valid_date_time_constraint_replacements" => {
                                ::core::result::Result::Ok(__Field::__F5)
                            }
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_TEMPORAL_DEFINITIONS",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::primitive::c_temporal_definitions::CTemporalDefinitions;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_TEMPORAL_DEFINITIONS` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "C_TEMPORAL_DEFINITIONS",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "valid_date_constraint_patterns",
                                    ),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "valid_date_constraint_replacements",
                                    ),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "valid_time_constraint_patterns",
                                    ),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "valid_time_constraint_replacements",
                                    ),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "valid_date_time_constraint_patterns",
                                    ),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "valid_date_time_constraint_replacements",
                                    ),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::primitive::c_temporal_definitions::CTemporalDefinitions {
valid_date_constraint_patterns: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("valid_date_constraint_patterns"))?,
valid_date_constraint_replacements: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("valid_date_constraint_replacements"))?,
valid_time_constraint_patterns: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("valid_time_constraint_patterns"))?,
valid_time_constraint_replacements: __s3.flatten().ok_or_else(|| ::serde::de::Error::missing_field("valid_time_constraint_replacements"))?,
valid_date_time_constraint_patterns: __s4.flatten().ok_or_else(|| ::serde::de::Error::missing_field("valid_date_time_constraint_patterns"))?,
valid_date_time_constraint_replacements: __s5.flatten().ok_or_else(|| ::serde::de::Error::missing_field("valid_date_time_constraint_replacements"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "C_TEMPORAL_DEFINITIONS",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::constraint_model::primitive::c_terminology_code::CTerminologyCode
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.parent.is_some() {
            __n += 1;
        }
        if self.soc_parent.is_some() {
            __n += 1;
        }
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self
            .alternative_ids
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.sibling_order.is_some() {
            __n += 1;
        }
        if self.default_value.is_some() {
            __n += 1;
        }
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.is_enumerated_type_constraint.is_some() {
            __n += 1;
        }
        if self.constraint_status.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "C_TERMINOLOGY_CODE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_TERMINOLOGY_CODE")?;
        if let Some(__v) = &self.parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent", __v)?;
        }
        if let Some(__v) = &self.soc_parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "soc_parent", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.alternative_ids
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "alternative_ids", __v)?;
        }
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.sibling_order {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "sibling_order", __v)?;
        }
        if let Some(__v) = &self.default_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "default_value", __v)?;
        }
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.is_enumerated_type_constraint {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_enumerated_type_constraint",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constraint", &self.constraint)?;
        if let Some(__v) = &self.constraint_status {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constraint_status", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::primitive::c_terminology_code::CTerminologyCode
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "alternative_ids",
            "assumed_value",
            "constraint",
            "constraint_status",
            "default_value",
            "is_deprecated",
            "is_enumerated_type_constraint",
            "node_id",
            "occurrences",
            "parent",
            "rm_type_name",
            "sibling_order",
            "soc_parent",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent" => ::core::result::Result::Ok(__Field::__F0),
                            "soc_parent" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F2),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F3),
                            "node_id" => ::core::result::Result::Ok(__Field::__F4),
                            "alternative_ids" => ::core::result::Result::Ok(__Field::__F5),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F6),
                            "sibling_order" => ::core::result::Result::Ok(__Field::__F7),
                            "default_value" => ::core::result::Result::Ok(__Field::__F8),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F9),
                            "is_enumerated_type_constraint" => {
                                ::core::result::Result::Ok(__Field::__F10)
                            }
                            "constraint" => ::core::result::Result::Ok(__Field::__F11),
                            "constraint_status" => ::core::result::Result::Ok(__Field::__F12),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "C_TERMINOLOGY_CODE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::primitive::c_terminology_code::CTerminologyCode;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_TERMINOLOGY_CODE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_TERMINOLOGY_CODE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("soc_parent"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("alternative_ids"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("sibling_order"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("default_value"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "is_enumerated_type_constraint",
                                    ),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constraint"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constraint_status"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::aom2::constraint_model::primitive::c_terminology_code::CTerminologyCode {
parent: __s0.flatten(),
soc_parent: __s1.flatten(),
rm_type_name: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
occurrences: __s3.flatten(),
node_id: __s4.flatten().ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
alternative_ids: __s5,
is_deprecated: __s6.flatten(),
sibling_order: __s7.flatten(),
default_value: __s8.flatten(),
assumed_value: __s9.flatten(),
is_enumerated_type_constraint: __s10.flatten(),
constraint: __s11.flatten().ok_or_else(|| ::serde::de::Error::missing_field("constraint"))?,
constraint_status: __s12.flatten(),
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "C_TERMINOLOGY_CODE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::primitive::c_time::CTime {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.parent.is_some() {
            __n += 1;
        }
        if self.soc_parent.is_some() {
            __n += 1;
        }
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self
            .alternative_ids
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.sibling_order.is_some() {
            __n += 1;
        }
        if self.default_value.is_some() {
            __n += 1;
        }
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.is_enumerated_type_constraint.is_some() {
            __n += 1;
        }
        if self.constraint.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.pattern_constraint.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "C_TIME", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "C_TIME")?;
        if let Some(__v) = &self.parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent", __v)?;
        }
        if let Some(__v) = &self.soc_parent {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "soc_parent", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.alternative_ids
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "alternative_ids", __v)?;
        }
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.sibling_order {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "sibling_order", __v)?;
        }
        if let Some(__v) = &self.default_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "default_value", __v)?;
        }
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.is_enumerated_type_constraint {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_enumerated_type_constraint",
                __v,
            )?;
        }
        if let Some(__v) = &self.constraint
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constraint", __v)?;
        }
        if let Some(__v) = &self.pattern_constraint {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "pattern_constraint", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::primitive::c_time::CTime
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "alternative_ids",
            "assumed_value",
            "constraint",
            "default_value",
            "is_deprecated",
            "is_enumerated_type_constraint",
            "node_id",
            "occurrences",
            "parent",
            "pattern_constraint",
            "rm_type_name",
            "sibling_order",
            "soc_parent",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent" => ::core::result::Result::Ok(__Field::__F0),
                            "soc_parent" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F2),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F3),
                            "node_id" => ::core::result::Result::Ok(__Field::__F4),
                            "alternative_ids" => ::core::result::Result::Ok(__Field::__F5),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F6),
                            "sibling_order" => ::core::result::Result::Ok(__Field::__F7),
                            "default_value" => ::core::result::Result::Ok(__Field::__F8),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F9),
                            "is_enumerated_type_constraint" => {
                                ::core::result::Result::Ok(__Field::__F10)
                            }
                            "constraint" => ::core::result::Result::Ok(__Field::__F11),
                            "pattern_constraint" => ::core::result::Result::Ok(__Field::__F12),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v, "C_TIME", __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::primitive::c_time::CTime;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `C_TIME` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<_> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("C_TIME"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("soc_parent"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("alternative_ids"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("sibling_order"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("default_value"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "is_enumerated_type_constraint",
                                    ),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constraint"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("pattern_constraint"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::constraint_model::primitive::c_time::CTime {
                        parent: __s0.flatten(),
                        soc_parent: __s1.flatten(),
                        rm_type_name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
                        occurrences: __s3.flatten(),
                        node_id: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
                        alternative_ids: __s5,
                        is_deprecated: __s6.flatten(),
                        sibling_order: __s7.flatten(),
                        default_value: __s8.flatten(),
                        assumed_value: __s9.flatten(),
                        is_enumerated_type_constraint: __s10.flatten(),
                        constraint: __s11,
                        pattern_constraint: __s12.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "C_TIME", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_agent::ElAgent {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::expression::el_agent::ElAgent::ElFunctionAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_agent::ElAgent::ElProcedureAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::expression::el_agent::ElAgent {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["EL_FUNCTION_AGENT", "EL_PROCEDURE_AGENT"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_agent::ElAgent;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_AGENT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
                            "EL_FUNCTION_AGENT" => ::core::result::Result::Ok(
                                crate::v2_4::bmm3::expression::el_agent::ElAgent::ElFunctionAgent(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(
                                crate::v2_4::bmm3::expression::el_agent::ElAgent::ElProcedureAgent(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            __other => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unexpected_type(
                                    "EL_AGENT",
                                    __other,
                                    "EL_FUNCTION_AGENT, EL_PROCEDURE_AGENT",
                                ),
                            ),
                        }
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_AGENT",
                            &__other,
                            "EL_FUNCTION_AGENT, EL_PROCEDURE_AGENT",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_AGENT",
                            "EL_FUNCTION_AGENT, EL_PROCEDURE_AGENT",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_agent_call::ElAgentCall {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::expression::el_agent_call::ElAgentCall::BmmProcedureCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_agent_call::ElAgentCall::ElFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::expression::el_agent_call::ElAgentCall {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_PROCEDURE_CALL", "EL_FUNCTION_CALL"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_agent_call::ElAgentCall;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_AGENT_CALL` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"BMM_PROCEDURE_CALL" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_agent_call::ElAgentCall::BmmProcedureCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_agent_call::ElAgentCall::ElFunctionCall(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EL_AGENT_CALL", __other, "BMM_PROCEDURE_CALL, EL_FUNCTION_CALL")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_AGENT_CALL",
                            &__other,
                            "BMM_PROCEDURE_CALL, EL_FUNCTION_CALL",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_AGENT_CALL",
                            "BMM_PROCEDURE_CALL, EL_FUNCTION_CALL",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_attached::ElAttached {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "EL_ATTACHED", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_ATTACHED")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "operand", &self.operand)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::expression::el_attached::ElAttached {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["operand"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "operand" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_ATTACHED",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_attached::ElAttached;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_ATTACHED` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_ATTACHED"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("operand"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_attached::ElAttached {
                    operand: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("operand"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_ATTACHED",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_binary_operator::ElBinaryOperator {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.precedence_overridden.is_some() {
            __n += 1;
        }
        if self.symbol.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "EL_BINARY_OPERATOR", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_BINARY_OPERATOR")?;
        if let Some(__v) = &self.precedence_overridden {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "precedence_overridden",
                __v,
            )?;
        }
        if let Some(__v) = &self.symbol {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "symbol", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "call", &self.call)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "left_operand",
            &self.left_operand,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "right_operand",
            &self.right_operand,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_binary_operator::ElBinaryOperator
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "call",
            "left_operand",
            "precedence_overridden",
            "right_operand",
            "symbol",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "precedence_overridden" => ::core::result::Result::Ok(__Field::__F0),
                            "symbol" => ::core::result::Result::Ok(__Field::__F1),
                            "call" => ::core::result::Result::Ok(__Field::__F2),
                            "left_operand" => ::core::result::Result::Ok(__Field::__F3),
                            "right_operand" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_BINARY_OPERATOR",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_binary_operator::ElBinaryOperator;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_BINARY_OPERATOR` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_BINARY_OPERATOR"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("precedence_overridden"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("symbol"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("call"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("left_operand"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("right_operand"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::expression::el_binary_operator::ElBinaryOperator {
                        precedence_overridden: __s0.flatten(),
                        symbol: __s1.flatten(),
                        call: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("call"))?,
                        left_operand: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("left_operand"))?,
                        right_operand: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("right_operand"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_BINARY_OPERATOR",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm3::expression::el_boolean_expression::ElBooleanExpression
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "EL_BOOLEAN_EXPRESSION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "EL_BOOLEAN_EXPRESSION",
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "base_expression",
            &self.base_expression,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_boolean_expression::ElBooleanExpression
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["base_expression"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "base_expression" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_BOOLEAN_EXPRESSION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_boolean_expression::ElBooleanExpression;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_BOOLEAN_EXPRESSION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "EL_BOOLEAN_EXPRESSION",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("base_expression"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::expression::el_boolean_expression::ElBooleanExpression {
                        base_expression: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("base_expression"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_BOOLEAN_EXPRESSION",
            __FIELDS,
            __Visitor,
        )
    }
}

impl<T: ::serde::Serialize> ::serde::Serialize
    for crate::v2_4::bmm3::expression::el_case::ElCase<T>
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "EL_CASE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_CASE")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "result", &self.result)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "value_constraint",
            &self.value_constraint,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de, T: ::serde::de::DeserializeOwned> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_case::ElCase<T>
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["result", "value_constraint"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "result" => ::core::result::Result::Ok(__Field::__F0),
                            "value_constraint" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v, "EL_CASE", __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor<T>(::core::marker::PhantomData<(T,)>);
        impl<'de, T: ::serde::de::DeserializeOwned> ::serde::de::Visitor<'de> for __Visitor<T> {
            type Value = crate::v2_4::bmm3::expression::el_case::ElCase<T>;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_CASE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_CASE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("result"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value_constraint"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_case::ElCase {
                    result: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("result"))?,
                    value_constraint: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("value_constraint"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_CASE",
            __FIELDS,
            __Visitor(::core::marker::PhantomData),
        )
    }
}

impl<T: ::serde::Serialize> ::serde::Serialize
    for crate::v2_4::bmm3::expression::el_case_table::ElCaseTable<T>
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "EL_CASE_TABLE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_CASE_TABLE")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "items", &self.items)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "else", &self.r#else)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "test_value", &self.test_value)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de, T: ::serde::de::DeserializeOwned> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_case_table::ElCaseTable<T>
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["else", "items", "test_value"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "items" => ::core::result::Result::Ok(__Field::__F0),
                            "else" => ::core::result::Result::Ok(__Field::__F1),
                            "test_value" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_CASE_TABLE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor<T>(::core::marker::PhantomData<(T,)>);
        impl<'de, T: ::serde::de::DeserializeOwned> ::serde::de::Visitor<'de> for __Visitor<T> {
            type Value = crate::v2_4::bmm3::expression::el_case_table::ElCaseTable<T>;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_CASE_TABLE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_CASE_TABLE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("items"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("else"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("test_value"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::expression::el_case_table::ElCaseTable {
                        items: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("items"))?,
                        r#else: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("else"))?,
                        test_value: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("test_value"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_CASE_TABLE",
            __FIELDS,
            __Visitor(::core::marker::PhantomData),
        )
    }
}

impl<T: ::serde::Serialize> ::serde::Serialize
    for crate::v2_4::bmm3::expression::el_conditional_expression::ElConditionalExpression<T>
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "EL_CONDITIONAL_EXPRESSION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "EL_CONDITIONAL_EXPRESSION",
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "result", &self.result)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "condition", &self.condition)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de, T: ::serde::de::DeserializeOwned> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_conditional_expression::ElConditionalExpression<T>
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["condition", "result"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "result" => ::core::result::Result::Ok(__Field::__F0),
                            "condition" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_CONDITIONAL_EXPRESSION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor<T>(::core::marker::PhantomData<(T,)>);
        impl<'de, T: ::serde::de::DeserializeOwned> ::serde::de::Visitor<'de> for __Visitor<T> {
            type Value =
                crate::v2_4::bmm3::expression::el_conditional_expression::ElConditionalExpression<
                    T,
                >;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_CONDITIONAL_EXPRESSION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "EL_CONDITIONAL_EXPRESSION",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("result"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("condition"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_conditional_expression::ElConditionalExpression {
result: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("result"))?,
condition: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("condition"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_CONDITIONAL_EXPRESSION",
            __FIELDS,
            __Visitor(::core::marker::PhantomData),
        )
    }
}

impl<T: ::serde::Serialize> ::serde::Serialize
    for crate::v2_4::bmm3::expression::el_condition_chain::ElConditionChain<T>
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "EL_CONDITION_CHAIN", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_CONDITION_CHAIN")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "items", &self.items)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "else", &self.r#else)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de, T: ::serde::de::DeserializeOwned> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_condition_chain::ElConditionChain<T>
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["else", "items"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "items" => ::core::result::Result::Ok(__Field::__F0),
                            "else" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_CONDITION_CHAIN",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor<T>(::core::marker::PhantomData<(T,)>);
        impl<'de, T: ::serde::de::DeserializeOwned> ::serde::de::Visitor<'de> for __Visitor<T> {
            type Value = crate::v2_4::bmm3::expression::el_condition_chain::ElConditionChain<T>;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_CONDITION_CHAIN` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_CONDITION_CHAIN"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("items"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("else"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::expression::el_condition_chain::ElConditionChain {
                        items: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("items"))?,
                        r#else: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("else"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_CONDITION_CHAIN",
            __FIELDS,
            __Visitor(::core::marker::PhantomData),
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_constrained::ElConstrained {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::expression::el_constrained::ElConstrained::ElBooleanExpression(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_constrained::ElConstrained
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["EL_BOOLEAN_EXPRESSION"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_constrained::ElConstrained;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_CONSTRAINED` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"EL_BOOLEAN_EXPRESSION" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_constrained::ElConstrained::ElBooleanExpression(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EL_CONSTRAINED", __other, "EL_BOOLEAN_EXPRESSION")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_CONSTRAINED",
                            &__other,
                            "EL_BOOLEAN_EXPRESSION",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_CONSTRAINED",
                            "EL_BOOLEAN_EXPRESSION",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl<T: ::serde::Serialize> ::serde::Serialize
    for crate::v2_4::bmm3::expression::el_decision_branch::ElDecisionBranch<T>
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm3::expression::el_decision_branch::ElDecisionBranch::ElCase(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::expression::el_decision_branch::ElDecisionBranch::ElConditionalExpression(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de, T: ::serde::de::DeserializeOwned> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_decision_branch::ElDecisionBranch<T>
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["EL_CASE", "EL_CONDITIONAL_EXPRESSION"];
        struct __Visitor<T>(::core::marker::PhantomData<(T,)>);
        impl<'de, T: ::serde::de::DeserializeOwned> ::serde::de::Visitor<'de> for __Visitor<T> {
            type Value = crate::v2_4::bmm3::expression::el_decision_branch::ElDecisionBranch<T>;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_DECISION_BRANCH` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"EL_CASE" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_decision_branch::ElDecisionBranch::ElCase(::serde::Deserialize::deserialize(__rest)?)),
"EL_CONDITIONAL_EXPRESSION" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_decision_branch::ElDecisionBranch::ElConditionalExpression(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EL_DECISION_BRANCH", __other, "EL_CASE, EL_CONDITIONAL_EXPRESSION")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_DECISION_BRANCH",
                            &__other,
                            "EL_CASE, EL_CONDITIONAL_EXPRESSION",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_DECISION_BRANCH",
                            "EL_CASE, EL_CONDITIONAL_EXPRESSION",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(
            __deserializer,
            __Visitor(::core::marker::PhantomData),
        )
    }
}

impl<T: ::serde::Serialize> ::serde::Serialize
    for crate::v2_4::bmm3::expression::el_decision_table::ElDecisionTable<T>
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::expression::el_decision_table::ElDecisionTable::ElCaseTable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_decision_table::ElDecisionTable::ElConditionChain(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de, T: ::serde::de::DeserializeOwned> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_decision_table::ElDecisionTable<T>
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["EL_CASE_TABLE", "EL_CONDITION_CHAIN"];
        struct __Visitor<T>(::core::marker::PhantomData<(T,)>);
        impl<'de, T: ::serde::de::DeserializeOwned> ::serde::de::Visitor<'de> for __Visitor<T> {
            type Value = crate::v2_4::bmm3::expression::el_decision_table::ElDecisionTable<T>;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_DECISION_TABLE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"EL_CASE_TABLE" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_decision_table::ElDecisionTable::ElCaseTable(::serde::Deserialize::deserialize(__rest)?)),
"EL_CONDITION_CHAIN" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_decision_table::ElDecisionTable::ElConditionChain(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EL_DECISION_TABLE", __other, "EL_CASE_TABLE, EL_CONDITION_CHAIN")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_DECISION_TABLE",
                            &__other,
                            "EL_CASE_TABLE, EL_CONDITION_CHAIN",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_DECISION_TABLE",
                            "EL_CASE_TABLE, EL_CONDITION_CHAIN",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(
            __deserializer,
            __Visitor(::core::marker::PhantomData),
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_defined::ElDefined {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "EL_DEFINED", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_DEFINED")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "operand", &self.operand)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::expression::el_defined::ElDefined {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["operand"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "operand" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_DEFINED",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_defined::ElDefined;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_DEFINED` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_DEFINED"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("operand"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_defined::ElDefined {
                    operand: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("operand"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "EL_DEFINED", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_expression::ElExpression {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::expression::el_expression::ElExpression::ElAttached(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_expression::ElExpression::ElBinaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_expression::ElExpression::ElBooleanExpression(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::bmm3::expression::el_expression::ElExpression::ElCaseTable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_expression::ElExpression::ElConditionChain(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_expression::ElExpression::ElDefined(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_expression::ElExpression::ElFunctionAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_expression::ElExpression::ElFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_expression::ElExpression::ElLiteral(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_expression::ElExpression::ElProcedureAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_expression::ElExpression::ElPropertyRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_expression::ElExpression::ElReadonlyVariable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_expression::ElExpression::ElStaticRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_expression::ElExpression::ElTuple(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_expression::ElExpression::ElTypeRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_expression::ElExpression::ElUnaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_expression::ElExpression::ElWritableVariable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::expression::el_expression::ElExpression {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "EL_ATTACHED",
            "EL_BINARY_OPERATOR",
            "EL_BOOLEAN_EXPRESSION",
            "EL_CASE_TABLE",
            "EL_CONDITION_CHAIN",
            "EL_DEFINED",
            "EL_FUNCTION_AGENT",
            "EL_FUNCTION_CALL",
            "EL_LITERAL",
            "EL_PROCEDURE_AGENT",
            "EL_PROPERTY_REF",
            "EL_READONLY_VARIABLE",
            "EL_STATIC_REF",
            "EL_TUPLE",
            "EL_TYPE_REF",
            "EL_UNARY_OPERATOR",
            "EL_WRITABLE_VARIABLE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_expression::ElExpression;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_EXPRESSION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"EL_ATTACHED" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_expression::ElExpression::ElAttached(::serde::Deserialize::deserialize(__rest)?)),
"EL_BINARY_OPERATOR" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_expression::ElExpression::ElBinaryOperator(::serde::Deserialize::deserialize(__rest)?)),
"EL_BOOLEAN_EXPRESSION" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_expression::ElExpression::ElBooleanExpression(::serde::Deserialize::deserialize(__rest)?)),
"EL_CASE_TABLE" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_expression::ElExpression::ElCaseTable(::serde::Deserialize::deserialize(__rest)?)),
"EL_CONDITION_CHAIN" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_expression::ElExpression::ElConditionChain(::serde::Deserialize::deserialize(__rest)?)),
"EL_DEFINED" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_expression::ElExpression::ElDefined(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_AGENT" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_expression::ElExpression::ElFunctionAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_expression::ElExpression::ElFunctionCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_LITERAL" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_expression::ElExpression::ElLiteral(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_expression::ElExpression::ElProcedureAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROPERTY_REF" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_expression::ElExpression::ElPropertyRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_READONLY_VARIABLE" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_expression::ElExpression::ElReadonlyVariable(::serde::Deserialize::deserialize(__rest)?)),
"EL_STATIC_REF" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_expression::ElExpression::ElStaticRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_TUPLE" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_expression::ElExpression::ElTuple(::serde::Deserialize::deserialize(__rest)?)),
"EL_TYPE_REF" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_expression::ElExpression::ElTypeRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_UNARY_OPERATOR" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_expression::ElExpression::ElUnaryOperator(::serde::Deserialize::deserialize(__rest)?)),
"EL_WRITABLE_VARIABLE" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_expression::ElExpression::ElWritableVariable(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EL_EXPRESSION", __other, "EL_ATTACHED, EL_BINARY_OPERATOR, EL_BOOLEAN_EXPRESSION, EL_CASE_TABLE, EL_CONDITION_CHAIN, EL_DEFINED, EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_LITERAL, EL_PROCEDURE_AGENT, EL_PROPERTY_REF, EL_READONLY_VARIABLE, EL_STATIC_REF, EL_TUPLE, EL_TYPE_REF, EL_UNARY_OPERATOR, EL_WRITABLE_VARIABLE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_EXPRESSION",
                            &__other,
                            "EL_ATTACHED, EL_BINARY_OPERATOR, EL_BOOLEAN_EXPRESSION, EL_CASE_TABLE, EL_CONDITION_CHAIN, EL_DEFINED, EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_LITERAL, EL_PROCEDURE_AGENT, EL_PROPERTY_REF, EL_READONLY_VARIABLE, EL_STATIC_REF, EL_TUPLE, EL_TYPE_REF, EL_UNARY_OPERATOR, EL_WRITABLE_VARIABLE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_EXPRESSION",
                            "EL_ATTACHED, EL_BINARY_OPERATOR, EL_BOOLEAN_EXPRESSION, EL_CASE_TABLE, EL_CONDITION_CHAIN, EL_DEFINED, EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_LITERAL, EL_PROCEDURE_AGENT, EL_PROPERTY_REF, EL_READONLY_VARIABLE, EL_STATIC_REF, EL_TUPLE, EL_TYPE_REF, EL_UNARY_OPERATOR, EL_WRITABLE_VARIABLE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_feature_ref::ElFeatureRef {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::expression::el_feature_ref::ElFeatureRef::ElFunctionAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_feature_ref::ElFeatureRef::ElFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_feature_ref::ElFeatureRef::ElProcedureAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_feature_ref::ElFeatureRef::ElPropertyRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_feature_ref::ElFeatureRef::ElStaticRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_feature_ref::ElFeatureRef
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "EL_FUNCTION_AGENT",
            "EL_FUNCTION_CALL",
            "EL_PROCEDURE_AGENT",
            "EL_PROPERTY_REF",
            "EL_STATIC_REF",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_feature_ref::ElFeatureRef;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_FEATURE_REF` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"EL_FUNCTION_AGENT" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_feature_ref::ElFeatureRef::ElFunctionAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_feature_ref::ElFeatureRef::ElFunctionCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_feature_ref::ElFeatureRef::ElProcedureAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROPERTY_REF" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_feature_ref::ElFeatureRef::ElPropertyRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_STATIC_REF" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_feature_ref::ElFeatureRef::ElStaticRef(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EL_FEATURE_REF", __other, "EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_PROCEDURE_AGENT, EL_PROPERTY_REF, EL_STATIC_REF")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_FEATURE_REF",
                            &__other,
                            "EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_PROCEDURE_AGENT, EL_PROPERTY_REF, EL_STATIC_REF",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_FEATURE_REF",
                            "EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_PROCEDURE_AGENT, EL_PROPERTY_REF, EL_STATIC_REF",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_function_agent::ElFunctionAgent {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.scoper.is_some() {
            __n += 1;
        }
        if self.closed_args.is_some() {
            __n += 1;
        }
        if self.open_args.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.definition.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "EL_FUNCTION_AGENT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_FUNCTION_AGENT")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_writable",
            &self.is_writable,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.scoper {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "scoper", __v)?;
        }
        if let Some(__v) = &self.closed_args {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "closed_args", __v)?;
        }
        if let Some(__v) = &self.open_args
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "open_args", __v)?;
        }
        if let Some(__v) = &self.definition {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_function_agent::ElFunctionAgent
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "closed_args",
            "definition",
            "is_writable",
            "name",
            "open_args",
            "scoper",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "is_writable" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "scoper" => ::core::result::Result::Ok(__Field::__F2),
                            "closed_args" => ::core::result::Result::Ok(__Field::__F3),
                            "open_args" => ::core::result::Result::Ok(__Field::__F4),
                            "definition" => ::core::result::Result::Ok(__Field::__F5),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_FUNCTION_AGENT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_function_agent::ElFunctionAgent;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_FUNCTION_AGENT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<_> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_FUNCTION_AGENT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_writable"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("scoper"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("closed_args"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("open_args"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("definition"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::expression::el_function_agent::ElFunctionAgent {
                        is_writable: __s0.flatten().unwrap_or(false),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        scoper: __s2.flatten(),
                        closed_args: __s3.flatten(),
                        open_args: __s4,
                        definition: __s5.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_FUNCTION_AGENT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_function_call::ElFunctionCall {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.scoper.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "EL_FUNCTION_CALL", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_FUNCTION_CALL")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_writable",
            &self.is_writable,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.scoper {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "scoper", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "agent", &self.agent)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_function_call::ElFunctionCall
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["agent", "is_writable", "name", "scoper"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "is_writable" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "scoper" => ::core::result::Result::Ok(__Field::__F2),
                            "agent" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_FUNCTION_CALL",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_function_call::ElFunctionCall;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_FUNCTION_CALL` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_FUNCTION_CALL"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_writable"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("scoper"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("agent"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::expression::el_function_call::ElFunctionCall {
                        is_writable: __s0.flatten().unwrap_or(false),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        scoper: __s2.flatten(),
                        agent: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("agent"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_FUNCTION_CALL",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_literal::ElLiteral {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "EL_LITERAL", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_LITERAL")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "value", &self.value)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::expression::el_literal::ElLiteral {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["value"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "value" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_LITERAL",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_literal::ElLiteral;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_LITERAL` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_LITERAL"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_literal::ElLiteral {
                    value: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("value"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "EL_LITERAL", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_operator::ElOperator {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::expression::el_operator::ElOperator::ElBinaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_operator::ElOperator::ElUnaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::expression::el_operator::ElOperator {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["EL_BINARY_OPERATOR", "EL_UNARY_OPERATOR"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_operator::ElOperator;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_OPERATOR` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"EL_BINARY_OPERATOR" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_operator::ElOperator::ElBinaryOperator(::serde::Deserialize::deserialize(__rest)?)),
"EL_UNARY_OPERATOR" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_operator::ElOperator::ElUnaryOperator(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EL_OPERATOR", __other, "EL_BINARY_OPERATOR, EL_UNARY_OPERATOR")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_OPERATOR",
                            &__other,
                            "EL_BINARY_OPERATOR, EL_UNARY_OPERATOR",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_OPERATOR",
                            "EL_BINARY_OPERATOR, EL_UNARY_OPERATOR",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_predicate::ElPredicate {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::expression::el_predicate::ElPredicate::ElAttached(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_predicate::ElPredicate::ElDefined(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::expression::el_predicate::ElPredicate {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["EL_ATTACHED", "EL_DEFINED"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_predicate::ElPredicate;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_PREDICATE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"EL_ATTACHED" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_predicate::ElPredicate::ElAttached(::serde::Deserialize::deserialize(__rest)?)),
"EL_DEFINED" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_predicate::ElPredicate::ElDefined(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EL_PREDICATE", __other, "EL_ATTACHED, EL_DEFINED")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_PREDICATE",
                            &__other,
                            "EL_ATTACHED, EL_DEFINED",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_PREDICATE",
                            "EL_ATTACHED, EL_DEFINED",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_procedure_agent::ElProcedureAgent {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.scoper.is_some() {
            __n += 1;
        }
        if self.closed_args.is_some() {
            __n += 1;
        }
        if self.open_args.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.definition.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "EL_PROCEDURE_AGENT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_PROCEDURE_AGENT")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_writable",
            &self.is_writable,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.scoper {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "scoper", __v)?;
        }
        if let Some(__v) = &self.closed_args {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "closed_args", __v)?;
        }
        if let Some(__v) = &self.open_args
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "open_args", __v)?;
        }
        if let Some(__v) = &self.definition {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_procedure_agent::ElProcedureAgent
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "closed_args",
            "definition",
            "is_writable",
            "name",
            "open_args",
            "scoper",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "is_writable" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "scoper" => ::core::result::Result::Ok(__Field::__F2),
                            "closed_args" => ::core::result::Result::Ok(__Field::__F3),
                            "open_args" => ::core::result::Result::Ok(__Field::__F4),
                            "definition" => ::core::result::Result::Ok(__Field::__F5),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_PROCEDURE_AGENT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_procedure_agent::ElProcedureAgent;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_PROCEDURE_AGENT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<_> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_PROCEDURE_AGENT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_writable"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("scoper"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("closed_args"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("open_args"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("definition"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::expression::el_procedure_agent::ElProcedureAgent {
                        is_writable: __s0.flatten().unwrap_or(false),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        scoper: __s2.flatten(),
                        closed_args: __s3.flatten(),
                        open_args: __s4,
                        definition: __s5.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_PROCEDURE_AGENT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_property_ref::ElPropertyRef {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.scoper.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "EL_PROPERTY_REF", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_PROPERTY_REF")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_writable",
            &self.is_writable,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.scoper {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "scoper", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", &self.definition)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_property_ref::ElPropertyRef
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["definition", "is_writable", "name", "scoper"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "is_writable" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "scoper" => ::core::result::Result::Ok(__Field::__F2),
                            "definition" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_PROPERTY_REF",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_property_ref::ElPropertyRef;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_PROPERTY_REF` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_PROPERTY_REF"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_writable"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("scoper"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("definition"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::expression::el_property_ref::ElPropertyRef {
                        is_writable: __s0.flatten().unwrap_or(true),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        scoper: __s2.flatten(),
                        definition: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("definition"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_PROPERTY_REF",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm3::expression::el_readonly_variable::ElReadonlyVariable
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "EL_READONLY_VARIABLE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_READONLY_VARIABLE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_writable",
            &self.is_writable,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", &self.definition)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_readonly_variable::ElReadonlyVariable
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["definition", "is_writable", "name"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "is_writable" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "definition" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_READONLY_VARIABLE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_readonly_variable::ElReadonlyVariable;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_READONLY_VARIABLE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_READONLY_VARIABLE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_writable"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("definition"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::expression::el_readonly_variable::ElReadonlyVariable {
                        is_writable: __s0.flatten().unwrap_or(false),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        definition: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("definition"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_READONLY_VARIABLE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_simple::ElSimple {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::expression::el_simple::ElSimple::ElAttached(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_simple::ElSimple::ElDefined(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_simple::ElSimple::ElFunctionAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_simple::ElSimple::ElFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_simple::ElSimple::ElLiteral(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_simple::ElSimple::ElProcedureAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_simple::ElSimple::ElPropertyRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_simple::ElSimple::ElReadonlyVariable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_simple::ElSimple::ElStaticRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_simple::ElSimple::ElTypeRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_simple::ElSimple::ElWritableVariable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::expression::el_simple::ElSimple {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "EL_ATTACHED",
            "EL_DEFINED",
            "EL_FUNCTION_AGENT",
            "EL_FUNCTION_CALL",
            "EL_LITERAL",
            "EL_PROCEDURE_AGENT",
            "EL_PROPERTY_REF",
            "EL_READONLY_VARIABLE",
            "EL_STATIC_REF",
            "EL_TYPE_REF",
            "EL_WRITABLE_VARIABLE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_simple::ElSimple;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_SIMPLE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"EL_ATTACHED" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_simple::ElSimple::ElAttached(::serde::Deserialize::deserialize(__rest)?)),
"EL_DEFINED" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_simple::ElSimple::ElDefined(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_AGENT" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_simple::ElSimple::ElFunctionAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_simple::ElSimple::ElFunctionCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_LITERAL" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_simple::ElSimple::ElLiteral(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_simple::ElSimple::ElProcedureAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROPERTY_REF" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_simple::ElSimple::ElPropertyRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_READONLY_VARIABLE" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_simple::ElSimple::ElReadonlyVariable(::serde::Deserialize::deserialize(__rest)?)),
"EL_STATIC_REF" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_simple::ElSimple::ElStaticRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_TYPE_REF" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_simple::ElSimple::ElTypeRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_WRITABLE_VARIABLE" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_simple::ElSimple::ElWritableVariable(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EL_SIMPLE", __other, "EL_ATTACHED, EL_DEFINED, EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_LITERAL, EL_PROCEDURE_AGENT, EL_PROPERTY_REF, EL_READONLY_VARIABLE, EL_STATIC_REF, EL_TYPE_REF, EL_WRITABLE_VARIABLE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_SIMPLE",
                            &__other,
                            "EL_ATTACHED, EL_DEFINED, EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_LITERAL, EL_PROCEDURE_AGENT, EL_PROPERTY_REF, EL_READONLY_VARIABLE, EL_STATIC_REF, EL_TYPE_REF, EL_WRITABLE_VARIABLE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_SIMPLE",
                            "EL_ATTACHED, EL_DEFINED, EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_LITERAL, EL_PROCEDURE_AGENT, EL_PROPERTY_REF, EL_READONLY_VARIABLE, EL_STATIC_REF, EL_TYPE_REF, EL_WRITABLE_VARIABLE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_static_ref::ElStaticRef {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.scoper.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "EL_STATIC_REF", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_STATIC_REF")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_writable",
            &self.is_writable,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.scoper {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "scoper", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", &self.definition)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::expression::el_static_ref::ElStaticRef {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["definition", "is_writable", "name", "scoper"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "is_writable" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "scoper" => ::core::result::Result::Ok(__Field::__F2),
                            "definition" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_STATIC_REF",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_static_ref::ElStaticRef;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_STATIC_REF` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_STATIC_REF"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_writable"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("scoper"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("definition"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::expression::el_static_ref::ElStaticRef {
                        is_writable: __s0.flatten().unwrap_or(false),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        scoper: __s2.flatten(),
                        definition: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("definition"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_STATIC_REF",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_terminal::ElTerminal {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElAttached(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElCaseTable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElConditionChain(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElDefined(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElFunctionAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElLiteral(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElProcedureAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElPropertyRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElReadonlyVariable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElStaticRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElTypeRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElWritableVariable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::expression::el_terminal::ElTerminal {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "EL_ATTACHED",
            "EL_CASE_TABLE",
            "EL_CONDITION_CHAIN",
            "EL_DEFINED",
            "EL_FUNCTION_AGENT",
            "EL_FUNCTION_CALL",
            "EL_LITERAL",
            "EL_PROCEDURE_AGENT",
            "EL_PROPERTY_REF",
            "EL_READONLY_VARIABLE",
            "EL_STATIC_REF",
            "EL_TYPE_REF",
            "EL_WRITABLE_VARIABLE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_terminal::ElTerminal;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_TERMINAL` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"EL_ATTACHED" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElAttached(::serde::Deserialize::deserialize(__rest)?)),
"EL_CASE_TABLE" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElCaseTable(::serde::Deserialize::deserialize(__rest)?)),
"EL_CONDITION_CHAIN" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElConditionChain(::serde::Deserialize::deserialize(__rest)?)),
"EL_DEFINED" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElDefined(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_AGENT" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElFunctionAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElFunctionCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_LITERAL" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElLiteral(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElProcedureAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROPERTY_REF" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElPropertyRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_READONLY_VARIABLE" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElReadonlyVariable(::serde::Deserialize::deserialize(__rest)?)),
"EL_STATIC_REF" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElStaticRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_TYPE_REF" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElTypeRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_WRITABLE_VARIABLE" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_terminal::ElTerminal::ElWritableVariable(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EL_TERMINAL", __other, "EL_ATTACHED, EL_CASE_TABLE, EL_CONDITION_CHAIN, EL_DEFINED, EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_LITERAL, EL_PROCEDURE_AGENT, EL_PROPERTY_REF, EL_READONLY_VARIABLE, EL_STATIC_REF, EL_TYPE_REF, EL_WRITABLE_VARIABLE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_TERMINAL",
                            &__other,
                            "EL_ATTACHED, EL_CASE_TABLE, EL_CONDITION_CHAIN, EL_DEFINED, EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_LITERAL, EL_PROCEDURE_AGENT, EL_PROPERTY_REF, EL_READONLY_VARIABLE, EL_STATIC_REF, EL_TYPE_REF, EL_WRITABLE_VARIABLE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_TERMINAL",
                            "EL_ATTACHED, EL_CASE_TABLE, EL_CONDITION_CHAIN, EL_DEFINED, EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_LITERAL, EL_PROCEDURE_AGENT, EL_PROPERTY_REF, EL_READONLY_VARIABLE, EL_STATIC_REF, EL_TYPE_REF, EL_WRITABLE_VARIABLE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_tuple::ElTuple {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.items.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "EL_TUPLE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_TUPLE")?;
        if let Some(__v) = &self.items
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "items", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::expression::el_tuple::ElTuple {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["items", "type"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "items" => ::core::result::Result::Ok(__Field::__F0),
                            "type" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v, "EL_TUPLE", __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_tuple::ElTuple;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_TUPLE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<_> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_TUPLE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("items"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_tuple::ElTuple {
                    items: __s0,
                    r#type: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "EL_TUPLE", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_tuple_item::ElTupleItem {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.item.is_some() {
            __n += 1;
        }
        if self.name.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "EL_TUPLE_ITEM", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_TUPLE_ITEM")?;
        if let Some(__v) = &self.item {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item", __v)?;
        }
        if let Some(__v) = &self.name {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::expression::el_tuple_item::ElTupleItem {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["item", "name"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "item" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_TUPLE_ITEM",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_tuple_item::ElTupleItem;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_TUPLE_ITEM` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_TUPLE_ITEM"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::expression::el_tuple_item::ElTupleItem {
                        item: __s0.flatten(),
                        name: __s1.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_TUPLE_ITEM",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_type_ref::ElTypeRef {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "EL_TYPE_REF", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_TYPE_REF")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_writable",
            &self.is_writable,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_mutable", &self.is_mutable)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::expression::el_type_ref::ElTypeRef {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["is_mutable", "is_writable", "name", "type"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "is_writable" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "type" => ::core::result::Result::Ok(__Field::__F2),
                            "is_mutable" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_TYPE_REF",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_type_ref::ElTypeRef;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_TYPE_REF` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_TYPE_REF"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_writable"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_mutable"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_type_ref::ElTypeRef {
                    is_writable: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("is_writable"))?,
                    name: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                    r#type: __s2
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                    is_mutable: __s3.flatten().unwrap_or(false),
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_TYPE_REF",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_unary_operator::ElUnaryOperator {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.precedence_overridden.is_some() {
            __n += 1;
        }
        if self.symbol.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "EL_UNARY_OPERATOR", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_UNARY_OPERATOR")?;
        if let Some(__v) = &self.precedence_overridden {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "precedence_overridden",
                __v,
            )?;
        }
        if let Some(__v) = &self.symbol {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "symbol", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "call", &self.call)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "operand", &self.operand)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_unary_operator::ElUnaryOperator
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["call", "operand", "precedence_overridden", "symbol"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "precedence_overridden" => ::core::result::Result::Ok(__Field::__F0),
                            "symbol" => ::core::result::Result::Ok(__Field::__F1),
                            "call" => ::core::result::Result::Ok(__Field::__F2),
                            "operand" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_UNARY_OPERATOR",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_unary_operator::ElUnaryOperator;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_UNARY_OPERATOR` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_UNARY_OPERATOR"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("precedence_overridden"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("symbol"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("call"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("operand"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::expression::el_unary_operator::ElUnaryOperator {
                        precedence_overridden: __s0.flatten(),
                        symbol: __s1.flatten(),
                        call: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("call"))?,
                        operand: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("operand"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_UNARY_OPERATOR",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator::ElFunctionAgent(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator::ElFunctionCall(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator::ElProcedureAgent(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator::ElPropertyRef(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator::ElReadonlyVariable(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator::ElStaticRef(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator::ElTypeRef(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator::ElWritableVariable(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "EL_FUNCTION_AGENT",
            "EL_FUNCTION_CALL",
            "EL_PROCEDURE_AGENT",
            "EL_PROPERTY_REF",
            "EL_READONLY_VARIABLE",
            "EL_STATIC_REF",
            "EL_TYPE_REF",
            "EL_WRITABLE_VARIABLE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_VALUE_GENERATOR` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"EL_FUNCTION_AGENT" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator::ElFunctionAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator::ElFunctionCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator::ElProcedureAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROPERTY_REF" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator::ElPropertyRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_READONLY_VARIABLE" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator::ElReadonlyVariable(::serde::Deserialize::deserialize(__rest)?)),
"EL_STATIC_REF" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator::ElStaticRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_TYPE_REF" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator::ElTypeRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_WRITABLE_VARIABLE" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_value_generator::ElValueGenerator::ElWritableVariable(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EL_VALUE_GENERATOR", __other, "EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_PROCEDURE_AGENT, EL_PROPERTY_REF, EL_READONLY_VARIABLE, EL_STATIC_REF, EL_TYPE_REF, EL_WRITABLE_VARIABLE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_VALUE_GENERATOR",
                            &__other,
                            "EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_PROCEDURE_AGENT, EL_PROPERTY_REF, EL_READONLY_VARIABLE, EL_STATIC_REF, EL_TYPE_REF, EL_WRITABLE_VARIABLE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_VALUE_GENERATOR",
                            "EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_PROCEDURE_AGENT, EL_PROPERTY_REF, EL_READONLY_VARIABLE, EL_STATIC_REF, EL_TYPE_REF, EL_WRITABLE_VARIABLE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm3::expression::el_variable::ElVariable {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm3::expression::el_variable::ElVariable::ElReadonlyVariable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm3::expression::el_variable::ElVariable::ElWritableVariable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm3::expression::el_variable::ElVariable {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["EL_READONLY_VARIABLE", "EL_WRITABLE_VARIABLE"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_variable::ElVariable;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_VARIABLE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"EL_READONLY_VARIABLE" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_variable::ElVariable::ElReadonlyVariable(::serde::Deserialize::deserialize(__rest)?)),
"EL_WRITABLE_VARIABLE" => ::core::result::Result::Ok(crate::v2_4::bmm3::expression::el_variable::ElVariable::ElWritableVariable(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EL_VARIABLE", __other, "EL_READONLY_VARIABLE, EL_WRITABLE_VARIABLE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_VARIABLE",
                            &__other,
                            "EL_READONLY_VARIABLE, EL_WRITABLE_VARIABLE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_VARIABLE",
                            "EL_READONLY_VARIABLE, EL_WRITABLE_VARIABLE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm3::expression::el_writable_variable::ElWritableVariable
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "EL_WRITABLE_VARIABLE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_WRITABLE_VARIABLE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_writable",
            &self.is_writable,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", &self.definition)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm3::expression::el_writable_variable::ElWritableVariable
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["definition", "is_writable", "name"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "is_writable" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "definition" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_WRITABLE_VARIABLE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm3::expression::el_writable_variable::ElWritableVariable;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_WRITABLE_VARIABLE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EL_WRITABLE_VARIABLE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_writable"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("definition"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm3::expression::el_writable_variable::ElWritableVariable {
                        is_writable: __s0.flatten().unwrap_or(true),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        definition: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("definition"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_WRITABLE_VARIABLE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::beom::core::expression::Expression {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::beom::core::expression::Expression::ExprBinaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expression::Expression::ExprConstraint(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expression::Expression::ExprForAll(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expression::Expression::ExprFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expression::Expression::ExprLiteral(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expression::Expression::ExprUnaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expression::Expression::ExprValueRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expression::Expression::ExprVariableRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::beom::core::expression::Expression {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "EXPR_ARCHETYPE_ID_CONSTRAINT",
            "EXPR_ARCHETYPE_REF",
            "EXPR_BINARY_OPERATOR",
            "EXPR_CONSTRAINT",
            "EXPR_FOR_ALL",
            "EXPR_FUNCTION_CALL",
            "EXPR_LITERAL",
            "EXPR_UNARY_OPERATOR",
            "EXPR_VALUE_REF",
            "EXPR_VARIABLE_REF",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::beom::core::expression::Expression;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPRESSION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
                            "EXPR_ARCHETYPE_ID_CONSTRAINT" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expression::Expression::ExprConstraint(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_ARCHETYPE_REF" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expression::Expression::ExprValueRef(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_BINARY_OPERATOR" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expression::Expression::ExprBinaryOperator(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_CONSTRAINT" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expression::Expression::ExprConstraint(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_FOR_ALL" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expression::Expression::ExprForAll(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_FUNCTION_CALL" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expression::Expression::ExprFunctionCall(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_LITERAL" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expression::Expression::ExprLiteral(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_UNARY_OPERATOR" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expression::Expression::ExprUnaryOperator(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_VALUE_REF" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expression::Expression::ExprValueRef(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_VARIABLE_REF" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expression::Expression::ExprVariableRef(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            __other => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unexpected_type(
                                    "EXPRESSION",
                                    __other,
                                    "EXPR_ARCHETYPE_ID_CONSTRAINT, EXPR_ARCHETYPE_REF, EXPR_BINARY_OPERATOR, EXPR_CONSTRAINT, EXPR_FOR_ALL, EXPR_FUNCTION_CALL, EXPR_LITERAL, EXPR_UNARY_OPERATOR, EXPR_VALUE_REF, EXPR_VARIABLE_REF",
                                ),
                            ),
                        }
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EXPRESSION",
                            &__other,
                            "EXPR_ARCHETYPE_ID_CONSTRAINT, EXPR_ARCHETYPE_REF, EXPR_BINARY_OPERATOR, EXPR_CONSTRAINT, EXPR_FOR_ALL, EXPR_FUNCTION_CALL, EXPR_LITERAL, EXPR_UNARY_OPERATOR, EXPR_VALUE_REF, EXPR_VARIABLE_REF",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EXPRESSION",
                            "EXPR_ARCHETYPE_ID_CONSTRAINT, EXPR_ARCHETYPE_REF, EXPR_BINARY_OPERATOR, EXPR_CONSTRAINT, EXPR_FOR_ALL, EXPR_FUNCTION_CALL, EXPR_LITERAL, EXPR_UNARY_OPERATOR, EXPR_VALUE_REF, EXPR_VARIABLE_REF",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::rules::expr_archetype_id_constraint::ExprArchetypeIdConstraint
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        let mut __st = ::serde::Serializer::serialize_struct(
            __serializer,
            "EXPR_ARCHETYPE_ID_CONSTRAINT",
            __n,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "EXPR_ARCHETYPE_ID_CONSTRAINT",
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item", &self.item)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::rules::expr_archetype_id_constraint::ExprArchetypeIdConstraint
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["item"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "item" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EXPR_ARCHETYPE_ID_CONSTRAINT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::aom2::rules::expr_archetype_id_constraint::ExprArchetypeIdConstraint;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_ARCHETYPE_ID_CONSTRAINT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "EXPR_ARCHETYPE_ID_CONSTRAINT",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::aom2::rules::expr_archetype_id_constraint::ExprArchetypeIdConstraint {
item: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("item"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EXPR_ARCHETYPE_ID_CONSTRAINT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::rules::expr_archetype_ref::ExprArchetypeRef {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "EXPR_ARCHETYPE_REF", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EXPR_ARCHETYPE_REF")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item", &self.item)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "path", &self.path)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::rules::expr_archetype_ref::ExprArchetypeRef
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["item", "path"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "item" => ::core::result::Result::Ok(__Field::__F0),
                            "path" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EXPR_ARCHETYPE_REF",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::rules::expr_archetype_ref::ExprArchetypeRef;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_ARCHETYPE_REF` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EXPR_ARCHETYPE_REF"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("path"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::rules::expr_archetype_ref::ExprArchetypeRef {
                        item: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("item"))?,
                        path: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("path"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EXPR_ARCHETYPE_REF",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::beom::core::expr_binary_operator::ExprBinaryOperator {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.precedence_overridden.is_some() {
            __n += 1;
        }
        if self.symbol.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "EXPR_BINARY_OPERATOR", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EXPR_BINARY_OPERATOR")?;
        if let Some(__v) = &self.precedence_overridden {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "precedence_overridden",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "operator", &self.operator)?;
        if let Some(__v) = &self.symbol {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "symbol", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "left_operand",
            &self.left_operand,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "right_operand",
            &self.right_operand,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::beom::core::expr_binary_operator::ExprBinaryOperator
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "left_operand",
            "operator",
            "precedence_overridden",
            "right_operand",
            "symbol",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "precedence_overridden" => ::core::result::Result::Ok(__Field::__F0),
                            "operator" => ::core::result::Result::Ok(__Field::__F1),
                            "symbol" => ::core::result::Result::Ok(__Field::__F2),
                            "left_operand" => ::core::result::Result::Ok(__Field::__F3),
                            "right_operand" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EXPR_BINARY_OPERATOR",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::beom::core::expr_binary_operator::ExprBinaryOperator;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_BINARY_OPERATOR` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EXPR_BINARY_OPERATOR"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("precedence_overridden"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("operator"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("symbol"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("left_operand"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("right_operand"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::beom::core::expr_binary_operator::ExprBinaryOperator {
                        precedence_overridden: __s0.flatten(),
                        operator: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("operator"))?,
                        symbol: __s2.flatten(),
                        left_operand: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("left_operand"))?,
                        right_operand: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("right_operand"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EXPR_BINARY_OPERATOR",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::rules::expr_constraint::ExprConstraintData {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "EXPR_CONSTRAINT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EXPR_CONSTRAINT")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item", &self.item)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::rules::expr_constraint::ExprConstraintData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["item"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "item" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EXPR_CONSTRAINT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::rules::expr_constraint::ExprConstraintData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_CONSTRAINT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EXPR_CONSTRAINT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::rules::expr_constraint::ExprConstraintData {
                        item: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("item"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EXPR_CONSTRAINT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::rules::expr_constraint::ExprConstraint {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::aom2::rules::expr_constraint::ExprConstraint::ExprArchetypeIdConstraint(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::rules::expr_constraint::ExprConstraint::ExprConstraint(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::aom2::rules::expr_constraint::ExprConstraint {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["EXPR_ARCHETYPE_ID_CONSTRAINT", "EXPR_CONSTRAINT"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::rules::expr_constraint::ExprConstraint;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_CONSTRAINT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"EXPR_ARCHETYPE_ID_CONSTRAINT" => ::core::result::Result::Ok(crate::v2_4::aom2::rules::expr_constraint::ExprConstraint::ExprArchetypeIdConstraint(::serde::Deserialize::deserialize(__rest)?)),
"EXPR_CONSTRAINT" => ::core::result::Result::Ok(crate::v2_4::aom2::rules::expr_constraint::ExprConstraint::ExprConstraint(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EXPR_CONSTRAINT", __other, "EXPR_ARCHETYPE_ID_CONSTRAINT, EXPR_CONSTRAINT")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EXPR_CONSTRAINT",
                            &__other,
                            "EXPR_ARCHETYPE_ID_CONSTRAINT, EXPR_CONSTRAINT",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::aom2::rules::expr_constraint::ExprConstraint::ExprConstraint(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::beom::core::expr_for_all::ExprForAll {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.precedence_overridden.is_some() {
            __n += 1;
        }
        if self.symbol.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "EXPR_FOR_ALL", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EXPR_FOR_ALL")?;
        if let Some(__v) = &self.precedence_overridden {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "precedence_overridden",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "operator", &self.operator)?;
        if let Some(__v) = &self.symbol {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "symbol", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "condition", &self.condition)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "operand", &self.operand)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::beom::core::expr_for_all::ExprForAll {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "condition",
            "operand",
            "operator",
            "precedence_overridden",
            "symbol",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "precedence_overridden" => ::core::result::Result::Ok(__Field::__F0),
                            "operator" => ::core::result::Result::Ok(__Field::__F1),
                            "symbol" => ::core::result::Result::Ok(__Field::__F2),
                            "condition" => ::core::result::Result::Ok(__Field::__F3),
                            "operand" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EXPR_FOR_ALL",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::beom::core::expr_for_all::ExprForAll;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_FOR_ALL` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EXPR_FOR_ALL"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("precedence_overridden"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("operator"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("symbol"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("condition"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("operand"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::beom::core::expr_for_all::ExprForAll {
                    precedence_overridden: __s0.flatten(),
                    operator: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("operator"))?,
                    symbol: __s2.flatten(),
                    condition: __s3
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("condition"))?,
                    operand: __s4
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("operand"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EXPR_FOR_ALL",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::beom::core::expr_function_call::ExprFunctionCall {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.item.is_some() {
            __n += 1;
        }
        if self.arguments.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "EXPR_FUNCTION_CALL", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EXPR_FUNCTION_CALL")?;
        if let Some(__v) = &self.item {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item", __v)?;
        }
        if let Some(__v) = &self.arguments
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "arguments", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::beom::core::expr_function_call::ExprFunctionCall
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["arguments", "item"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "item" => ::core::result::Result::Ok(__Field::__F0),
                            "arguments" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EXPR_FUNCTION_CALL",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::beom::core::expr_function_call::ExprFunctionCall;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_FUNCTION_CALL` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EXPR_FUNCTION_CALL"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("arguments"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::beom::core::expr_function_call::ExprFunctionCall {
                        item: __s0.flatten(),
                        arguments: __s1,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EXPR_FUNCTION_CALL",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::beom::core::expr_leaf::ExprLeaf {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::beom::core::expr_leaf::ExprLeaf::ExprConstraint(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expr_leaf::ExprLeaf::ExprFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expr_leaf::ExprLeaf::ExprLiteral(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expr_leaf::ExprLeaf::ExprValueRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expr_leaf::ExprLeaf::ExprVariableRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::beom::core::expr_leaf::ExprLeaf {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "EXPR_ARCHETYPE_ID_CONSTRAINT",
            "EXPR_ARCHETYPE_REF",
            "EXPR_CONSTRAINT",
            "EXPR_FUNCTION_CALL",
            "EXPR_LITERAL",
            "EXPR_VALUE_REF",
            "EXPR_VARIABLE_REF",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::beom::core::expr_leaf::ExprLeaf;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_LEAF` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
                            "EXPR_ARCHETYPE_ID_CONSTRAINT" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_leaf::ExprLeaf::ExprConstraint(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_ARCHETYPE_REF" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_leaf::ExprLeaf::ExprValueRef(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_CONSTRAINT" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_leaf::ExprLeaf::ExprConstraint(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_FUNCTION_CALL" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_leaf::ExprLeaf::ExprFunctionCall(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_LITERAL" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_leaf::ExprLeaf::ExprLiteral(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_VALUE_REF" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_leaf::ExprLeaf::ExprValueRef(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_VARIABLE_REF" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_leaf::ExprLeaf::ExprVariableRef(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            __other => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unexpected_type(
                                    "EXPR_LEAF",
                                    __other,
                                    "EXPR_ARCHETYPE_ID_CONSTRAINT, EXPR_ARCHETYPE_REF, EXPR_CONSTRAINT, EXPR_FUNCTION_CALL, EXPR_LITERAL, EXPR_VALUE_REF, EXPR_VARIABLE_REF",
                                ),
                            ),
                        }
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EXPR_LEAF",
                            &__other,
                            "EXPR_ARCHETYPE_ID_CONSTRAINT, EXPR_ARCHETYPE_REF, EXPR_CONSTRAINT, EXPR_FUNCTION_CALL, EXPR_LITERAL, EXPR_VALUE_REF, EXPR_VARIABLE_REF",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EXPR_LEAF",
                            "EXPR_ARCHETYPE_ID_CONSTRAINT, EXPR_ARCHETYPE_REF, EXPR_CONSTRAINT, EXPR_FUNCTION_CALL, EXPR_LITERAL, EXPR_VALUE_REF, EXPR_VARIABLE_REF",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::beom::core::expr_operator::ExprOperator {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::beom::core::expr_operator::ExprOperator::ExprBinaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expr_operator::ExprOperator::ExprForAll(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expr_operator::ExprOperator::ExprUnaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::beom::core::expr_operator::ExprOperator {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "EXPR_BINARY_OPERATOR",
            "EXPR_FOR_ALL",
            "EXPR_UNARY_OPERATOR",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::beom::core::expr_operator::ExprOperator;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_OPERATOR` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"EXPR_BINARY_OPERATOR" => ::core::result::Result::Ok(crate::v2_4::beom::core::expr_operator::ExprOperator::ExprBinaryOperator(::serde::Deserialize::deserialize(__rest)?)),
"EXPR_FOR_ALL" => ::core::result::Result::Ok(crate::v2_4::beom::core::expr_operator::ExprOperator::ExprForAll(::serde::Deserialize::deserialize(__rest)?)),
"EXPR_UNARY_OPERATOR" => ::core::result::Result::Ok(crate::v2_4::beom::core::expr_operator::ExprOperator::ExprUnaryOperator(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EXPR_OPERATOR", __other, "EXPR_BINARY_OPERATOR, EXPR_FOR_ALL, EXPR_UNARY_OPERATOR")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EXPR_OPERATOR",
                            &__other,
                            "EXPR_BINARY_OPERATOR, EXPR_FOR_ALL, EXPR_UNARY_OPERATOR",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EXPR_OPERATOR",
                            "EXPR_BINARY_OPERATOR, EXPR_FOR_ALL, EXPR_UNARY_OPERATOR",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::beom::core::expr_unary_operator::ExprUnaryOperator {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.precedence_overridden.is_some() {
            __n += 1;
        }
        if self.symbol.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "EXPR_UNARY_OPERATOR", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EXPR_UNARY_OPERATOR")?;
        if let Some(__v) = &self.precedence_overridden {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "precedence_overridden",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "operator", &self.operator)?;
        if let Some(__v) = &self.symbol {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "symbol", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "operand", &self.operand)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::beom::core::expr_unary_operator::ExprUnaryOperator
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["operand", "operator", "precedence_overridden", "symbol"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "precedence_overridden" => ::core::result::Result::Ok(__Field::__F0),
                            "operator" => ::core::result::Result::Ok(__Field::__F1),
                            "symbol" => ::core::result::Result::Ok(__Field::__F2),
                            "operand" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EXPR_UNARY_OPERATOR",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::beom::core::expr_unary_operator::ExprUnaryOperator;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_UNARY_OPERATOR` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EXPR_UNARY_OPERATOR"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("precedence_overridden"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("operator"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("symbol"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("operand"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::beom::core::expr_unary_operator::ExprUnaryOperator {
                        precedence_overridden: __s0.flatten(),
                        operator: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("operator"))?,
                        symbol: __s2.flatten(),
                        operand: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("operand"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EXPR_UNARY_OPERATOR",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::beom::core::expr_value::ExprValue {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::beom::core::expr_value::ExprValue::ExprBinaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expr_value::ExprValue::ExprConstraint(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expr_value::ExprValue::ExprForAll(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expr_value::ExprValue::ExprFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expr_value::ExprValue::ExprLiteral(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expr_value::ExprValue::ExprUnaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expr_value::ExprValue::ExprValueRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expr_value::ExprValue::ExprVariableRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expr_value::ExprValue::ExternalQuery(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::beom::core::expr_value::ExprValue {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "EXPR_ARCHETYPE_ID_CONSTRAINT",
            "EXPR_ARCHETYPE_REF",
            "EXPR_BINARY_OPERATOR",
            "EXPR_CONSTRAINT",
            "EXPR_FOR_ALL",
            "EXPR_FUNCTION_CALL",
            "EXPR_LITERAL",
            "EXPR_UNARY_OPERATOR",
            "EXPR_VALUE_REF",
            "EXPR_VARIABLE_REF",
            "EXTERNAL_QUERY",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::beom::core::expr_value::ExprValue;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_VALUE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
                            "EXPR_ARCHETYPE_ID_CONSTRAINT" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_value::ExprValue::ExprConstraint(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_ARCHETYPE_REF" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_value::ExprValue::ExprValueRef(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_BINARY_OPERATOR" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_value::ExprValue::ExprBinaryOperator(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_CONSTRAINT" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_value::ExprValue::ExprConstraint(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_FOR_ALL" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_value::ExprValue::ExprForAll(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_FUNCTION_CALL" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_value::ExprValue::ExprFunctionCall(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_LITERAL" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_value::ExprValue::ExprLiteral(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_UNARY_OPERATOR" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_value::ExprValue::ExprUnaryOperator(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_VALUE_REF" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_value::ExprValue::ExprValueRef(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_VARIABLE_REF" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_value::ExprValue::ExprVariableRef(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXTERNAL_QUERY" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::expr_value::ExprValue::ExternalQuery(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            __other => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unexpected_type(
                                    "EXPR_VALUE",
                                    __other,
                                    "EXPR_ARCHETYPE_ID_CONSTRAINT, EXPR_ARCHETYPE_REF, EXPR_BINARY_OPERATOR, EXPR_CONSTRAINT, EXPR_FOR_ALL, EXPR_FUNCTION_CALL, EXPR_LITERAL, EXPR_UNARY_OPERATOR, EXPR_VALUE_REF, EXPR_VARIABLE_REF, EXTERNAL_QUERY",
                                ),
                            ),
                        }
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EXPR_VALUE",
                            &__other,
                            "EXPR_ARCHETYPE_ID_CONSTRAINT, EXPR_ARCHETYPE_REF, EXPR_BINARY_OPERATOR, EXPR_CONSTRAINT, EXPR_FOR_ALL, EXPR_FUNCTION_CALL, EXPR_LITERAL, EXPR_UNARY_OPERATOR, EXPR_VALUE_REF, EXPR_VARIABLE_REF, EXTERNAL_QUERY",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EXPR_VALUE",
                            "EXPR_ARCHETYPE_ID_CONSTRAINT, EXPR_ARCHETYPE_REF, EXPR_BINARY_OPERATOR, EXPR_CONSTRAINT, EXPR_FOR_ALL, EXPR_FUNCTION_CALL, EXPR_LITERAL, EXPR_UNARY_OPERATOR, EXPR_VALUE_REF, EXPR_VARIABLE_REF, EXTERNAL_QUERY",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::beom::core::expr_value_ref::ExprValueRefData {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.item.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "EXPR_VALUE_REF", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EXPR_VALUE_REF")?;
        if let Some(__v) = &self.item {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::beom::core::expr_value_ref::ExprValueRefData {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["item"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "item" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EXPR_VALUE_REF",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::beom::core::expr_value_ref::ExprValueRefData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_VALUE_REF` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("EXPR_VALUE_REF"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::beom::core::expr_value_ref::ExprValueRefData {
                        item: __s0.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EXPR_VALUE_REF",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::beom::core::expr_value_ref::ExprValueRef {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::beom::core::expr_value_ref::ExprValueRef::ExprArchetypeRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::expr_value_ref::ExprValueRef::ExprValueRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::beom::core::expr_value_ref::ExprValueRef {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["EXPR_ARCHETYPE_REF", "EXPR_VALUE_REF"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::beom::core::expr_value_ref::ExprValueRef;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_VALUE_REF` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"EXPR_ARCHETYPE_REF" => ::core::result::Result::Ok(crate::v2_4::beom::core::expr_value_ref::ExprValueRef::ExprArchetypeRef(::serde::Deserialize::deserialize(__rest)?)),
"EXPR_VALUE_REF" => ::core::result::Result::Ok(crate::v2_4::beom::core::expr_value_ref::ExprValueRef::ExprValueRef(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EXPR_VALUE_REF", __other, "EXPR_ARCHETYPE_REF, EXPR_VALUE_REF")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EXPR_VALUE_REF",
                            &__other,
                            "EXPR_ARCHETYPE_REF, EXPR_VALUE_REF",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(
                            crate::v2_4::beom::core::expr_value_ref::ExprValueRef::ExprValueRef(
                                ::serde::Deserialize::deserialize(__rest)?,
                            ),
                        )
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::archetype::operational_template::OperationalTemplate
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 10usize;
        if self.parent_archetype_id.is_some() {
            __n += 1;
        }
        if self.rules.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.rm_overlay.is_some() {
            __n += 1;
        }
        if self.uid.is_some() {
            __n += 1;
        }
        if self.description.is_some() {
            __n += 1;
        }
        if self.is_controlled.is_some() {
            __n += 1;
        }
        if self.annotations.is_some() {
            __n += 1;
        }
        if self.translations.is_some() {
            __n += 1;
        }
        if self.adl_version.is_some() {
            __n += 1;
        }
        if self.component_terminologies.is_some() {
            __n += 1;
        }
        if self.terminology_extracts.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "OPERATIONAL_TEMPLATE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "OPERATIONAL_TEMPLATE")?;
        if let Some(__v) = &self.parent_archetype_id {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent_archetype_id", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "archetype_id",
            &self.archetype_id,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_differential",
            &self.is_differential,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", &self.definition)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "terminology",
            &self.terminology,
        )?;
        if let Some(__v) = &self.rules
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rules", __v)?;
        }
        if let Some(__v) = &self.rm_overlay {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_overlay", __v)?;
        }
        if let Some(__v) = &self.uid {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "uid", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "original_language",
            &self.original_language,
        )?;
        if let Some(__v) = &self.description {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "description", __v)?;
        }
        if let Some(__v) = &self.is_controlled {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_controlled", __v)?;
        }
        if let Some(__v) = &self.annotations {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "annotations", __v)?;
        }
        if let Some(__v) = &self.translations {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "translations", __v)?;
        }
        if let Some(__v) = &self.adl_version {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "adl_version", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "build_uid", &self.build_uid)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_release", &self.rm_release)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_generated",
            &self.is_generated,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "other_meta_data",
            &self.other_meta_data,
        )?;
        if let Some(__v) = &self.component_terminologies {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "component_terminologies",
                __v,
            )?;
        }
        if let Some(__v) = &self.terminology_extracts {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "terminology_extracts", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::archetype::operational_template::OperationalTemplate
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "adl_version",
            "annotations",
            "archetype_id",
            "build_uid",
            "component_terminologies",
            "definition",
            "description",
            "is_controlled",
            "is_differential",
            "is_generated",
            "original_language",
            "other_meta_data",
            "parent_archetype_id",
            "rm_overlay",
            "rm_release",
            "rules",
            "terminology",
            "terminology_extracts",
            "translations",
            "uid",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
            __F14,
            __F15,
            __F16,
            __F17,
            __F18,
            __F19,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent_archetype_id" => ::core::result::Result::Ok(__Field::__F0),
                            "archetype_id" => ::core::result::Result::Ok(__Field::__F1),
                            "is_differential" => ::core::result::Result::Ok(__Field::__F2),
                            "definition" => ::core::result::Result::Ok(__Field::__F3),
                            "terminology" => ::core::result::Result::Ok(__Field::__F4),
                            "rules" => ::core::result::Result::Ok(__Field::__F5),
                            "rm_overlay" => ::core::result::Result::Ok(__Field::__F6),
                            "uid" => ::core::result::Result::Ok(__Field::__F7),
                            "original_language" => ::core::result::Result::Ok(__Field::__F8),
                            "description" => ::core::result::Result::Ok(__Field::__F9),
                            "is_controlled" => ::core::result::Result::Ok(__Field::__F10),
                            "annotations" => ::core::result::Result::Ok(__Field::__F11),
                            "translations" => ::core::result::Result::Ok(__Field::__F12),
                            "adl_version" => ::core::result::Result::Ok(__Field::__F13),
                            "build_uid" => ::core::result::Result::Ok(__Field::__F14),
                            "rm_release" => ::core::result::Result::Ok(__Field::__F15),
                            "is_generated" => ::core::result::Result::Ok(__Field::__F16),
                            "other_meta_data" => ::core::result::Result::Ok(__Field::__F17),
                            "component_terminologies" => ::core::result::Result::Ok(__Field::__F18),
                            "terminology_extracts" => ::core::result::Result::Ok(__Field::__F19),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "OPERATIONAL_TEMPLATE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::archetype::operational_template::OperationalTemplate;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `OPERATIONAL_TEMPLATE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s14: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s15: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s16: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s17: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s18: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s19: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("OPERATIONAL_TEMPLATE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent_archetype_id"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("archetype_id"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_differential"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("definition"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("terminology"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rules"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_overlay"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("uid"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("original_language"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("description"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_controlled"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("annotations"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("translations"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("adl_version"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F14 => {
                            if __s14.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("build_uid"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F15 => {
                            if __s15.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_release"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F16 => {
                            if __s16.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_generated"),
                                );
                            }
                            __s16 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F17 => {
                            if __s17.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("other_meta_data"),
                                );
                            }
                            __s17 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F18 => {
                            if __s18.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("component_terminologies"),
                                );
                            }
                            __s18 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F19 => {
                            if __s19.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("terminology_extracts"),
                                );
                            }
                            __s19 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::archetype::operational_template::OperationalTemplate {
                        parent_archetype_id: __s0.flatten(),
                        archetype_id: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("archetype_id"))?,
                        is_differential: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_differential"))?,
                        definition: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("definition"))?,
                        terminology: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("terminology"))?,
                        rules: __s5,
                        rm_overlay: __s6.flatten(),
                        uid: __s7.flatten(),
                        original_language: __s8.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("original_language")
                        })?,
                        description: __s9.flatten(),
                        is_controlled: __s10.flatten(),
                        annotations: __s11.flatten(),
                        translations: __s12.flatten(),
                        adl_version: __s13.flatten(),
                        build_uid: __s14
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("build_uid"))?,
                        rm_release: __s15
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_release"))?,
                        is_generated: __s16
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_generated"))?,
                        other_meta_data: __s17
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("other_meta_data"))?,
                        component_terminologies: __s18.flatten(),
                        terminology_extracts: __s19.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "OPERATIONAL_TEMPLATE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::persistence::archetype::p_archetype::PArchetype {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::aom2::persistence::archetype::p_archetype::PArchetype::PAuthoredArchetype(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::archetype::p_archetype::PArchetype
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "P_AUTHORED_ARCHETYPE",
            "P_OPERATIONAL_TEMPLATE",
            "P_TEMPLATE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::archetype::p_archetype::PArchetype;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_ARCHETYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_AUTHORED_ARCHETYPE" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::archetype::p_archetype::PArchetype::PAuthoredArchetype(::serde::Deserialize::deserialize(__rest)?)),
"P_OPERATIONAL_TEMPLATE" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::archetype::p_archetype::PArchetype::PAuthoredArchetype(::serde::Deserialize::deserialize(__rest)?)),
"P_TEMPLATE" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::archetype::p_archetype::PArchetype::PAuthoredArchetype(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_ARCHETYPE", __other, "P_AUTHORED_ARCHETYPE, P_OPERATIONAL_TEMPLATE, P_TEMPLATE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "P_ARCHETYPE",
                            &__other,
                            "P_AUTHORED_ARCHETYPE, P_OPERATIONAL_TEMPLATE, P_TEMPLATE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "P_ARCHETYPE",
                            "P_AUTHORED_ARCHETYPE, P_OPERATIONAL_TEMPLATE, P_TEMPLATE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint {
fn serialize<__S: ::serde::Serializer>(&self, __serializer: __S) -> ::core::result::Result<__S::Ok, __S::Error> { match self {
crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint::PArchetypeSlot(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint::PCAttribute(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint::PCBoolean(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint::PCComplexObject(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint::PCComplexObjectProxy(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint::PCString(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint::PCTerminologyCode(__x) => ::serde::Serialize::serialize(__x, __serializer),
} }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint {
fn deserialize<__D: ::serde::Deserializer<'de>>(__deserializer: __D) -> ::core::result::Result<Self, __D::Error> {
const __TAGS: &[&str] = &["P_ARCHETYPE_SLOT", "P_C_ARCHETYPE_ROOT", "P_C_ATTRIBUTE", "P_C_BOOLEAN", "P_C_COMPLEX_OBJECT", "P_C_COMPLEX_OBJECT_PROXY", "P_C_STRING", "P_C_TERMINOLOGY_CODE"];
struct __Visitor;
impl<'de> ::serde::de::Visitor<'de> for __Visitor {
type Value = crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint;
fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
__f.write_str("an openEHR `P_ARCHETYPE_CONSTRAINT` object")
}
fn visit_map<__A: ::serde::de::MapAccess<'de>>(self, mut __map: __A) -> ::core::result::Result<Self::Value, __A::Error> {
let (__tag, __buffered) = ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
match __tag {
Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
let __rest = ::openehr_base::serde_support::TaggedRest::new(Some(__t), __buffered, __map);
match __t {
"P_ARCHETYPE_SLOT" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint::PArchetypeSlot(::serde::Deserialize::deserialize(__rest)?)),
"P_C_ARCHETYPE_ROOT" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint::PCComplexObject(::serde::Deserialize::deserialize(__rest)?)),
"P_C_ATTRIBUTE" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint::PCAttribute(::serde::Deserialize::deserialize(__rest)?)),
"P_C_BOOLEAN" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint::PCBoolean(::serde::Deserialize::deserialize(__rest)?)),
"P_C_COMPLEX_OBJECT" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint::PCComplexObject(::serde::Deserialize::deserialize(__rest)?)),
"P_C_COMPLEX_OBJECT_PROXY" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint::PCComplexObjectProxy(::serde::Deserialize::deserialize(__rest)?)),
"P_C_STRING" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint::PCString(::serde::Deserialize::deserialize(__rest)?)),
"P_C_TERMINOLOGY_CODE" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_archetype_constraint::PArchetypeConstraint::PCTerminologyCode(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_ARCHETYPE_CONSTRAINT", __other, "P_ARCHETYPE_SLOT, P_C_ARCHETYPE_ROOT, P_C_ATTRIBUTE, P_C_BOOLEAN, P_C_COMPLEX_OBJECT, P_C_COMPLEX_OBJECT_PROXY, P_C_STRING, P_C_TERMINOLOGY_CODE")),
}
}
Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_ARCHETYPE_CONSTRAINT", &__other, "P_ARCHETYPE_SLOT, P_C_ARCHETYPE_ROOT, P_C_ATTRIBUTE, P_C_BOOLEAN, P_C_COMPLEX_OBJECT, P_C_COMPLEX_OBJECT_PROXY, P_C_STRING, P_C_TERMINOLOGY_CODE")),
None => ::core::result::Result::Err(::openehr_base::serde_support::missing_type("P_ARCHETYPE_CONSTRAINT", "P_ARCHETYPE_SLOT, P_C_ARCHETYPE_ROOT, P_C_ATTRIBUTE, P_C_BOOLEAN, P_C_COMPLEX_OBJECT, P_C_COMPLEX_OBJECT_PROXY, P_C_STRING, P_C_TERMINOLOGY_CODE")),
}
}
}
::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
}
}

impl ::serde::Serialize
    for crate::v2_4::aom2::persistence::archetype::p_archetype_hrid::PArchetypeHrid
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 8usize;
        if self.namespace.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_ARCHETYPE_HRID", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_ARCHETYPE_HRID")?;
        if let Some(__v) = &self.namespace {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "namespace", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_publisher",
            &self.rm_publisher,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_package", &self.rm_package)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_class", &self.rm_class)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "concept_id", &self.concept_id)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "release_version",
            &self.release_version,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "version_status",
            &self.version_status,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "build_count",
            &self.build_count,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::archetype::p_archetype_hrid::PArchetypeHrid
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "build_count",
            "concept_id",
            "namespace",
            "release_version",
            "rm_class",
            "rm_package",
            "rm_publisher",
            "version_status",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "namespace" => ::core::result::Result::Ok(__Field::__F0),
                            "rm_publisher" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_package" => ::core::result::Result::Ok(__Field::__F2),
                            "rm_class" => ::core::result::Result::Ok(__Field::__F3),
                            "concept_id" => ::core::result::Result::Ok(__Field::__F4),
                            "release_version" => ::core::result::Result::Ok(__Field::__F5),
                            "version_status" => ::core::result::Result::Ok(__Field::__F6),
                            "build_count" => ::core::result::Result::Ok(__Field::__F7),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_ARCHETYPE_HRID",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::aom2::persistence::archetype::p_archetype_hrid::PArchetypeHrid;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_ARCHETYPE_HRID` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_ARCHETYPE_HRID"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("namespace"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_publisher"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_package"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_class"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("concept_id"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("release_version"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("version_status"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("build_count"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::persistence::archetype::p_archetype_hrid::PArchetypeHrid {
                        namespace: __s0.flatten(),
                        rm_publisher: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_publisher"))?,
                        rm_package: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_package"))?,
                        rm_class: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_class"))?,
                        concept_id: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("concept_id"))?,
                        release_version: __s5
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("release_version"))?,
                        version_status: __s6
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("version_status"))?,
                        build_count: __s7
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("build_count"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_ARCHETYPE_HRID",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::persistence::constraint_model::p_archetype_slot::PArchetypeSlot
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.includes.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.excludes.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_ARCHETYPE_SLOT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_ARCHETYPE_SLOT")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.includes
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "includes", __v)?;
        }
        if let Some(__v) = &self.excludes
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "excludes", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_closed", &self.is_closed)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::constraint_model::p_archetype_slot::PArchetypeSlot
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "excludes",
            "includes",
            "is_closed",
            "is_deprecated",
            "node_id",
            "occurrences",
            "rm_type_name",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F1),
                            "node_id" => ::core::result::Result::Ok(__Field::__F2),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F3),
                            "includes" => ::core::result::Result::Ok(__Field::__F4),
                            "excludes" => ::core::result::Result::Ok(__Field::__F5),
                            "is_closed" => ::core::result::Result::Ok(__Field::__F6),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_ARCHETYPE_SLOT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::aom2::persistence::constraint_model::p_archetype_slot::PArchetypeSlot;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_ARCHETYPE_SLOT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<_> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_ARCHETYPE_SLOT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("includes"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("excludes"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_closed"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_archetype_slot::PArchetypeSlot {
rm_type_name: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
occurrences: __s1.flatten(),
node_id: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
is_deprecated: __s3.flatten(),
includes: __s4,
excludes: __s5,
is_closed: __s6.flatten().ok_or_else(|| ::serde::de::Error::missing_field("is_closed"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_ARCHETYPE_SLOT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::persistence::terminology::p_archetype_terminology::PArchetypeTerminology
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.term_bindings.is_some() {
            __n += 1;
        }
        if self.value_sets.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_ARCHETYPE_TERMINOLOGY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "P_ARCHETYPE_TERMINOLOGY",
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_differential",
            &self.is_differential,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "original_language",
            &self.original_language,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "term_definitions",
            &self.term_definitions,
        )?;
        if let Some(__v) = &self.term_bindings {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "term_bindings", __v)?;
        }
        if let Some(__v) = &self.value_sets {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "value_sets", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::terminology::p_archetype_terminology::PArchetypeTerminology
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "is_differential",
            "original_language",
            "term_bindings",
            "term_definitions",
            "value_sets",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "is_differential" => ::core::result::Result::Ok(__Field::__F0),
                            "original_language" => ::core::result::Result::Ok(__Field::__F1),
                            "term_definitions" => ::core::result::Result::Ok(__Field::__F2),
                            "term_bindings" => ::core::result::Result::Ok(__Field::__F3),
                            "value_sets" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_ARCHETYPE_TERMINOLOGY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::terminology::p_archetype_terminology::PArchetypeTerminology;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_ARCHETYPE_TERMINOLOGY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "P_ARCHETYPE_TERMINOLOGY",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_differential"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("original_language"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("term_definitions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("term_bindings"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value_sets"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::aom2::persistence::terminology::p_archetype_terminology::PArchetypeTerminology {
is_differential: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("is_differential"))?,
original_language: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("original_language"))?,
term_definitions: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("term_definitions"))?,
term_bindings: __s3.flatten(),
value_sets: __s4.flatten(),
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_ARCHETYPE_TERMINOLOGY",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::persistence::archetype::p_authored_archetype::PAuthoredArchetypeData
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 10usize;
        if self.parent_archetype_id.is_some() {
            __n += 1;
        }
        if self.rules.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.uid.is_some() {
            __n += 1;
        }
        if self.description.is_some() {
            __n += 1;
        }
        if self.is_controlled.is_some() {
            __n += 1;
        }
        if self.annotations.is_some() {
            __n += 1;
        }
        if self
            .translations
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.adl_version.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_AUTHORED_ARCHETYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_AUTHORED_ARCHETYPE")?;
        if let Some(__v) = &self.parent_archetype_id {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent_archetype_id", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "archetype_id",
            &self.archetype_id,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_differential",
            &self.is_differential,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", &self.definition)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "terminology",
            &self.terminology,
        )?;
        if let Some(__v) = &self.rules
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rules", __v)?;
        }
        if let Some(__v) = &self.uid {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "uid", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "original_language",
            &self.original_language,
        )?;
        if let Some(__v) = &self.description {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "description", __v)?;
        }
        if let Some(__v) = &self.is_controlled {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_controlled", __v)?;
        }
        if let Some(__v) = &self.annotations {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "annotations", __v)?;
        }
        if let Some(__v) = &self.translations
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "translations", __v)?;
        }
        if let Some(__v) = &self.adl_version {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "adl_version", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "build_uid", &self.build_uid)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_release", &self.rm_release)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_generated",
            &self.is_generated,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "other_meta_data",
            &self.other_meta_data,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::archetype::p_authored_archetype::PAuthoredArchetypeData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "adl_version",
            "annotations",
            "archetype_id",
            "build_uid",
            "definition",
            "description",
            "is_controlled",
            "is_differential",
            "is_generated",
            "original_language",
            "other_meta_data",
            "parent_archetype_id",
            "rm_release",
            "rules",
            "terminology",
            "translations",
            "uid",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
            __F14,
            __F15,
            __F16,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent_archetype_id" => ::core::result::Result::Ok(__Field::__F0),
                            "archetype_id" => ::core::result::Result::Ok(__Field::__F1),
                            "is_differential" => ::core::result::Result::Ok(__Field::__F2),
                            "definition" => ::core::result::Result::Ok(__Field::__F3),
                            "terminology" => ::core::result::Result::Ok(__Field::__F4),
                            "rules" => ::core::result::Result::Ok(__Field::__F5),
                            "uid" => ::core::result::Result::Ok(__Field::__F6),
                            "original_language" => ::core::result::Result::Ok(__Field::__F7),
                            "description" => ::core::result::Result::Ok(__Field::__F8),
                            "is_controlled" => ::core::result::Result::Ok(__Field::__F9),
                            "annotations" => ::core::result::Result::Ok(__Field::__F10),
                            "translations" => ::core::result::Result::Ok(__Field::__F11),
                            "adl_version" => ::core::result::Result::Ok(__Field::__F12),
                            "build_uid" => ::core::result::Result::Ok(__Field::__F13),
                            "rm_release" => ::core::result::Result::Ok(__Field::__F14),
                            "is_generated" => ::core::result::Result::Ok(__Field::__F15),
                            "other_meta_data" => ::core::result::Result::Ok(__Field::__F16),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_AUTHORED_ARCHETYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::archetype::p_authored_archetype::PAuthoredArchetypeData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_AUTHORED_ARCHETYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<_> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s14: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s15: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s16: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_AUTHORED_ARCHETYPE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent_archetype_id"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("archetype_id"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_differential"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("definition"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("terminology"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rules"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("uid"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("original_language"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("description"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_controlled"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("annotations"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("translations"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("adl_version"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("build_uid"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F14 => {
                            if __s14.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_release"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F15 => {
                            if __s15.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_generated"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F16 => {
                            if __s16.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("other_meta_data"),
                                );
                            }
                            __s16 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::aom2::persistence::archetype::p_authored_archetype::PAuthoredArchetypeData {
parent_archetype_id: __s0.flatten(),
archetype_id: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("archetype_id"))?,
is_differential: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("is_differential"))?,
definition: __s3.flatten().ok_or_else(|| ::serde::de::Error::missing_field("definition"))?,
terminology: __s4.flatten().ok_or_else(|| ::serde::de::Error::missing_field("terminology"))?,
rules: __s5,
uid: __s6.flatten(),
original_language: __s7.flatten().ok_or_else(|| ::serde::de::Error::missing_field("original_language"))?,
description: __s8.flatten(),
is_controlled: __s9.flatten(),
annotations: __s10.flatten(),
translations: __s11,
adl_version: __s12.flatten(),
build_uid: __s13.flatten().ok_or_else(|| ::serde::de::Error::missing_field("build_uid"))?,
rm_release: __s14.flatten().ok_or_else(|| ::serde::de::Error::missing_field("rm_release"))?,
is_generated: __s15.flatten().ok_or_else(|| ::serde::de::Error::missing_field("is_generated"))?,
other_meta_data: __s16.flatten().ok_or_else(|| ::serde::de::Error::missing_field("other_meta_data"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_AUTHORED_ARCHETYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::persistence::archetype::p_authored_archetype::PAuthoredArchetype
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::aom2::persistence::archetype::p_authored_archetype::PAuthoredArchetype::POperationalTemplate(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::archetype::p_authored_archetype::PAuthoredArchetype::PTemplate(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::archetype::p_authored_archetype::PAuthoredArchetype::PAuthoredArchetype(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::archetype::p_authored_archetype::PAuthoredArchetype
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "P_AUTHORED_ARCHETYPE",
            "P_OPERATIONAL_TEMPLATE",
            "P_TEMPLATE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::aom2::persistence::archetype::p_authored_archetype::PAuthoredArchetype;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_AUTHORED_ARCHETYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_AUTHORED_ARCHETYPE" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::archetype::p_authored_archetype::PAuthoredArchetype::PAuthoredArchetype(::serde::Deserialize::deserialize(__rest)?)),
"P_OPERATIONAL_TEMPLATE" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::archetype::p_authored_archetype::PAuthoredArchetype::POperationalTemplate(::serde::Deserialize::deserialize(__rest)?)),
"P_TEMPLATE" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::archetype::p_authored_archetype::PAuthoredArchetype::PTemplate(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_AUTHORED_ARCHETYPE", __other, "P_AUTHORED_ARCHETYPE, P_OPERATIONAL_TEMPLATE, P_TEMPLATE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "P_AUTHORED_ARCHETYPE",
                            &__other,
                            "P_AUTHORED_ARCHETYPE, P_OPERATIONAL_TEMPLATE, P_TEMPLATE",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::aom2::persistence::archetype::p_authored_archetype::PAuthoredArchetype::PAuthoredArchetype(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::persistence::archetype::p_authored_resource::PAuthoredResource
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::aom2::persistence::archetype::p_authored_resource::PAuthoredResource::PAuthoredArchetype(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::archetype::p_authored_resource::PAuthoredResource
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "P_AUTHORED_ARCHETYPE",
            "P_OPERATIONAL_TEMPLATE",
            "P_TEMPLATE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::aom2::persistence::archetype::p_authored_resource::PAuthoredResource;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_AUTHORED_RESOURCE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_AUTHORED_ARCHETYPE" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::archetype::p_authored_resource::PAuthoredResource::PAuthoredArchetype(::serde::Deserialize::deserialize(__rest)?)),
"P_OPERATIONAL_TEMPLATE" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::archetype::p_authored_resource::PAuthoredResource::PAuthoredArchetype(::serde::Deserialize::deserialize(__rest)?)),
"P_TEMPLATE" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::archetype::p_authored_resource::PAuthoredResource::PAuthoredArchetype(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_AUTHORED_RESOURCE", __other, "P_AUTHORED_ARCHETYPE, P_OPERATIONAL_TEMPLATE, P_TEMPLATE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "P_AUTHORED_RESOURCE",
                            &__other,
                            "P_AUTHORED_ARCHETYPE, P_OPERATIONAL_TEMPLATE, P_TEMPLATE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "P_AUTHORED_RESOURCE",
                            "P_AUTHORED_ARCHETYPE, P_OPERATIONAL_TEMPLATE, P_TEMPLATE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm_persistence::p_bmm_base_type::PBmmBaseType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm_persistence::p_bmm_base_type::PBmmBaseType::PBmmGenericType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm_persistence::p_bmm_base_type::PBmmBaseType::PBmmOpenType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm_persistence::p_bmm_base_type::PBmmBaseType::PBmmSimpleType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_base_type::PBmmBaseType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["P_BMM_GENERIC_TYPE", "P_BMM_OPEN_TYPE", "P_BMM_SIMPLE_TYPE"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_base_type::PBmmBaseType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_BASE_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_BMM_GENERIC_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_base_type::PBmmBaseType::PBmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_OPEN_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_base_type::PBmmBaseType::PBmmOpenType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_base_type::PBmmBaseType::PBmmSimpleType(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_BMM_BASE_TYPE", __other, "P_BMM_GENERIC_TYPE, P_BMM_OPEN_TYPE, P_BMM_SIMPLE_TYPE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "P_BMM_BASE_TYPE",
                            &__other,
                            "P_BMM_GENERIC_TYPE, P_BMM_OPEN_TYPE, P_BMM_SIMPLE_TYPE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "P_BMM_BASE_TYPE",
                            "P_BMM_GENERIC_TYPE, P_BMM_OPEN_TYPE, P_BMM_SIMPLE_TYPE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm_persistence::p_bmm_class::PBmmClassData {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.ancestors.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.constants.is_some() {
            __n += 1;
        }
        if self.properties.is_some() {
            __n += 1;
        }
        if self.functions.is_some() {
            __n += 1;
        }
        if self.invariants.is_some() {
            __n += 1;
        }
        if self.is_abstract.is_some() {
            __n += 1;
        }
        if self.is_override.is_some() {
            __n += 1;
        }
        if self.generic_parameter_defs.is_some() {
            __n += 1;
        }
        if self.bmm_class.is_some() {
            __n += 1;
        }
        if self
            .ancestor_defs
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_BMM_CLASS", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_BMM_CLASS")?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.ancestors
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "ancestors", __v)?;
        }
        if let Some(__v) = &self.constants {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constants", __v)?;
        }
        if let Some(__v) = &self.properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "properties", __v)?;
        }
        if let Some(__v) = &self.functions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "functions", __v)?;
        }
        if let Some(__v) = &self.invariants {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "invariants", __v)?;
        }
        if let Some(__v) = &self.is_abstract {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_abstract", __v)?;
        }
        if let Some(__v) = &self.is_override {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_override", __v)?;
        }
        if let Some(__v) = &self.generic_parameter_defs {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "generic_parameter_defs",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "source_schema_id",
            &self.source_schema_id,
        )?;
        if let Some(__v) = &self.bmm_class {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_class", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "uid", &self.uid)?;
        if let Some(__v) = &self.ancestor_defs
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "ancestor_defs", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm_persistence::p_bmm_class::PBmmClassData {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "ancestor_defs",
            "ancestors",
            "bmm_class",
            "constants",
            "documentation",
            "functions",
            "generic_parameter_defs",
            "invariants",
            "is_abstract",
            "is_override",
            "name",
            "properties",
            "source_schema_id",
            "uid",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F2),
                            "constants" => ::core::result::Result::Ok(__Field::__F3),
                            "properties" => ::core::result::Result::Ok(__Field::__F4),
                            "functions" => ::core::result::Result::Ok(__Field::__F5),
                            "invariants" => ::core::result::Result::Ok(__Field::__F6),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F7),
                            "is_override" => ::core::result::Result::Ok(__Field::__F8),
                            "generic_parameter_defs" => ::core::result::Result::Ok(__Field::__F9),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F10),
                            "bmm_class" => ::core::result::Result::Ok(__Field::__F11),
                            "uid" => ::core::result::Result::Ok(__Field::__F12),
                            "ancestor_defs" => ::core::result::Result::Ok(__Field::__F13),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_CLASS",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_class::PBmmClassData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_CLASS` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<_> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_BMM_CLASS"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("ancestors"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constants"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("properties"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("functions"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("invariants"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_abstract"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_override"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("generic_parameter_defs"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("source_schema_id"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_class"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("uid"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("ancestor_defs"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm_persistence::p_bmm_class::PBmmClassData {
                        documentation: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        ancestors: __s2,
                        constants: __s3.flatten(),
                        properties: __s4.flatten(),
                        functions: __s5.flatten(),
                        invariants: __s6.flatten(),
                        is_abstract: __s7.flatten(),
                        is_override: __s8.flatten(),
                        generic_parameter_defs: __s9.flatten(),
                        source_schema_id: __s10
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                        bmm_class: __s11.flatten(),
                        uid: __s12
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("uid"))?,
                        ancestor_defs: __s13,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_CLASS",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm_persistence::p_bmm_class::PBmmClass {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm_persistence::p_bmm_class::PBmmClass::PBmmEnumeration(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm_persistence::p_bmm_class::PBmmClass::PBmmInterface(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm_persistence::p_bmm_class::PBmmClass::PBmmClass(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm_persistence::p_bmm_class::PBmmClass {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "P_BMM_CLASS",
            "P_BMM_ENUMERATION",
            "P_BMM_ENUMERATION_INTEGER",
            "P_BMM_ENUMERATION_STRING",
            "P_BMM_INTERFACE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_class::PBmmClass;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_CLASS` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_BMM_CLASS" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_class::PBmmClass::PBmmClass(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_class::PBmmClass::PBmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_class::PBmmClass::PBmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_class::PBmmClass::PBmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INTERFACE" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_class::PBmmClass::PBmmInterface(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_BMM_CLASS", __other, "P_BMM_CLASS, P_BMM_ENUMERATION, P_BMM_ENUMERATION_INTEGER, P_BMM_ENUMERATION_STRING, P_BMM_INTERFACE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "P_BMM_CLASS",
                            &__other,
                            "P_BMM_CLASS, P_BMM_ENUMERATION, P_BMM_ENUMERATION_INTEGER, P_BMM_ENUMERATION_STRING, P_BMM_INTERFACE",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(
                            crate::v2_4::bmm_persistence::p_bmm_class::PBmmClass::PBmmClass(
                                ::serde::Deserialize::deserialize(__rest)?,
                            ),
                        )
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm_persistence::p_bmm_container_function_parameter::PBmmContainerFunctionParameter {
fn serialize<__S: ::serde::Serializer>(&self, __serializer: __S) -> ::core::result::Result<__S::Ok, __S::Error> {
let mut __n = 3usize;
if self.documentation.is_some() { __n += 1; }
if self.is_nullable.is_some() { __n += 1; }
if self.cardinality.is_some() { __n += 1; }
let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_BMM_CONTAINER_FUNCTION_PARAMETER", __n)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_BMM_CONTAINER_FUNCTION_PARAMETER")?;
if let Some(__v) = &self.documentation { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?; }
::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
if let Some(__v) = &self.is_nullable { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?; }
::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_def", &self.type_def)?;
if let Some(__v) = &self.cardinality { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "cardinality", __v)?; }
::serde::ser::SerializeStruct::end(__st)
}
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm_persistence::p_bmm_container_function_parameter::PBmmContainerFunctionParameter {
fn deserialize<__D: ::serde::Deserializer<'de>>(__deserializer: __D) -> ::core::result::Result<Self, __D::Error> {
const __FIELDS: &[&str] = &["cardinality", "documentation", "is_nullable", "name", "type_def"];
enum __Field { __Type, __F0, __F1, __F2, __F3, __F4, }
impl<'de> ::serde::Deserialize<'de> for __Field {
fn deserialize<__D: ::serde::Deserializer<'de>>(__deserializer: __D) -> ::core::result::Result<Self, __D::Error> {
struct __KeyVisitor;
impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
type Value = __Field;
fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
__f.write_str("an object member name")
}
fn visit_str<__E: ::serde::de::Error>(self, __v: &str) -> ::core::result::Result<__Field, __E> {
match __v {
"_type" => ::core::result::Result::Ok(__Field::__Type),
"documentation" => ::core::result::Result::Ok(__Field::__F0),
"name" => ::core::result::Result::Ok(__Field::__F1),
"is_nullable" => ::core::result::Result::Ok(__Field::__F2),
"type_def" => ::core::result::Result::Ok(__Field::__F3),
"cardinality" => ::core::result::Result::Ok(__Field::__F4),
_ => ::core::result::Result::Err(::openehr_base::serde_support::unknown_field(__v, "P_BMM_CONTAINER_FUNCTION_PARAMETER", __FIELDS)),
}
}
}
::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
}
}
struct __Visitor;
impl<'de> ::serde::de::Visitor<'de> for __Visitor {
type Value = crate::v2_4::bmm_persistence::p_bmm_container_function_parameter::PBmmContainerFunctionParameter;
fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
__f.write_str("an openEHR `P_BMM_CONTAINER_FUNCTION_PARAMETER` object")
}
fn visit_map<__A: ::serde::de::MapAccess<'de>>(self, mut __map: __A) -> ::core::result::Result<Self::Value, __A::Error> {
let mut __seen_type = false;
let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
 match __key {
__Field::__Type => {
if __seen_type { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("_type")); }
__seen_type = true;
::serde::de::MapAccess::next_value_seed(&mut __map, ::openehr_base::serde_support::ExpectedType("P_BMM_CONTAINER_FUNCTION_PARAMETER"))?;
}
__Field::__F0 => {
if __s0.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("documentation")); }
__s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F1 => {
if __s1.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("name")); }
__s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F2 => {
if __s2.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("is_nullable")); }
__s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F3 => {
if __s3.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("type_def")); }
__s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F4 => {
if __s4.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("cardinality")); }
__s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
}
}
::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_container_function_parameter::PBmmContainerFunctionParameter {
documentation: __s0.flatten(),
name: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
is_nullable: __s2.flatten(),
type_def: __s3.flatten().ok_or_else(|| ::serde::de::Error::missing_field("type_def"))?,
cardinality: __s4.flatten(),
})
}
}
::serde::Deserializer::deserialize_struct(__deserializer, "P_BMM_CONTAINER_FUNCTION_PARAMETER", __FIELDS, __Visitor)
}
}

impl ::serde::Serialize
    for crate::v2_4::bmm_persistence::p_bmm_container_property::PBmmContainerPropertyData
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.is_mandatory.is_some() {
            __n += 1;
        }
        if self.is_computed.is_some() {
            __n += 1;
        }
        if self.is_im_infrastructure.is_some() {
            __n += 1;
        }
        if self.is_im_runtime.is_some() {
            __n += 1;
        }
        if self.type_def.is_some() {
            __n += 1;
        }
        if self.bmm_property.is_some() {
            __n += 1;
        }
        if self.cardinality.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_BMM_CONTAINER_PROPERTY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "P_BMM_CONTAINER_PROPERTY",
        )?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.is_mandatory {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_mandatory", __v)?;
        }
        if let Some(__v) = &self.is_computed {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_computed", __v)?;
        }
        if let Some(__v) = &self.is_im_infrastructure {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_im_infrastructure", __v)?;
        }
        if let Some(__v) = &self.is_im_runtime {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_im_runtime", __v)?;
        }
        if let Some(__v) = &self.type_def {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_def", __v)?;
        }
        if let Some(__v) = &self.bmm_property {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_property", __v)?;
        }
        if let Some(__v) = &self.cardinality {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "cardinality", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_container_property::PBmmContainerPropertyData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "bmm_property",
            "cardinality",
            "documentation",
            "is_computed",
            "is_im_infrastructure",
            "is_im_runtime",
            "is_mandatory",
            "name",
            "type_def",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "is_mandatory" => ::core::result::Result::Ok(__Field::__F2),
                            "is_computed" => ::core::result::Result::Ok(__Field::__F3),
                            "is_im_infrastructure" => ::core::result::Result::Ok(__Field::__F4),
                            "is_im_runtime" => ::core::result::Result::Ok(__Field::__F5),
                            "type_def" => ::core::result::Result::Ok(__Field::__F6),
                            "bmm_property" => ::core::result::Result::Ok(__Field::__F7),
                            "cardinality" => ::core::result::Result::Ok(__Field::__F8),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_CONTAINER_PROPERTY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm_persistence::p_bmm_container_property::PBmmContainerPropertyData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_CONTAINER_PROPERTY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "P_BMM_CONTAINER_PROPERTY",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_mandatory"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_computed"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_im_infrastructure"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_im_runtime"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type_def"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_property"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("cardinality"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_container_property::PBmmContainerPropertyData {
documentation: __s0.flatten(),
name: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
is_mandatory: __s2.flatten(),
is_computed: __s3.flatten(),
is_im_infrastructure: __s4.flatten(),
is_im_runtime: __s5.flatten(),
type_def: __s6.flatten(),
bmm_property: __s7.flatten(),
cardinality: __s8.flatten(),
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_CONTAINER_PROPERTY",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm_persistence::p_bmm_container_property::PBmmContainerProperty
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm_persistence::p_bmm_container_property::PBmmContainerProperty::PBmmIndexedContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_container_property::PBmmContainerProperty::PBmmContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_container_property::PBmmContainerProperty
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "P_BMM_CONTAINER_PROPERTY",
            "P_BMM_INDEXED_CONTAINER_PROPERTY",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm_persistence::p_bmm_container_property::PBmmContainerProperty;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_CONTAINER_PROPERTY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_container_property::PBmmContainerProperty::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_container_property::PBmmContainerProperty::PBmmIndexedContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_BMM_CONTAINER_PROPERTY", __other, "P_BMM_CONTAINER_PROPERTY, P_BMM_INDEXED_CONTAINER_PROPERTY")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "P_BMM_CONTAINER_PROPERTY",
                            &__other,
                            "P_BMM_CONTAINER_PROPERTY, P_BMM_INDEXED_CONTAINER_PROPERTY",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_container_property::PBmmContainerProperty::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm_persistence::p_bmm_container_type::PBmmContainerTypeData
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.bmm_type.is_some() {
            __n += 1;
        }
        if self.type_def.is_some() {
            __n += 1;
        }
        if self.r#type.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_BMM_CONTAINER_TYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_BMM_CONTAINER_TYPE")?;
        if let Some(__v) = &self.bmm_type {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_type", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "container_type",
            &self.container_type,
        )?;
        if let Some(__v) = &self.type_def {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_def", __v)?;
        }
        if let Some(__v) = &self.r#type {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_container_type::PBmmContainerTypeData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["bmm_type", "container_type", "type", "type_def"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "bmm_type" => ::core::result::Result::Ok(__Field::__F0),
                            "container_type" => ::core::result::Result::Ok(__Field::__F1),
                            "type_def" => ::core::result::Result::Ok(__Field::__F2),
                            "type" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_CONTAINER_TYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_container_type::PBmmContainerTypeData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_CONTAINER_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_BMM_CONTAINER_TYPE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_type"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("container_type"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type_def"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm_persistence::p_bmm_container_type::PBmmContainerTypeData {
                        bmm_type: __s0.flatten(),
                        container_type: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("container_type"))?,
                        type_def: __s2.flatten(),
                        r#type: __s3.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_CONTAINER_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm_persistence::p_bmm_container_type::PBmmContainerType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm_persistence::p_bmm_container_type::PBmmContainerType::PBmmIndexedContainerType(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_container_type::PBmmContainerType::PBmmContainerType(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_container_type::PBmmContainerType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["P_BMM_CONTAINER_TYPE", "P_BMM_INDEXED_CONTAINER_TYPE"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_container_type::PBmmContainerType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_CONTAINER_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_BMM_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_container_type::PBmmContainerType::PBmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_container_type::PBmmContainerType::PBmmIndexedContainerType(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_BMM_CONTAINER_TYPE", __other, "P_BMM_CONTAINER_TYPE, P_BMM_INDEXED_CONTAINER_TYPE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "P_BMM_CONTAINER_TYPE",
                            &__other,
                            "P_BMM_CONTAINER_TYPE, P_BMM_INDEXED_CONTAINER_TYPE",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_container_type::PBmmContainerType::PBmmContainerType(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm_persistence::p_bmm_enumeration::PBmmEnumerationData {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.ancestors.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.constants.is_some() {
            __n += 1;
        }
        if self.properties.is_some() {
            __n += 1;
        }
        if self.functions.is_some() {
            __n += 1;
        }
        if self.invariants.is_some() {
            __n += 1;
        }
        if self.is_abstract.is_some() {
            __n += 1;
        }
        if self.is_override.is_some() {
            __n += 1;
        }
        if self.generic_parameter_defs.is_some() {
            __n += 1;
        }
        if self.bmm_class.is_some() {
            __n += 1;
        }
        if self
            .ancestor_defs
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.item_names.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.item_values.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self
            .item_documentations
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_BMM_ENUMERATION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_BMM_ENUMERATION")?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.ancestors
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "ancestors", __v)?;
        }
        if let Some(__v) = &self.constants {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constants", __v)?;
        }
        if let Some(__v) = &self.properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "properties", __v)?;
        }
        if let Some(__v) = &self.functions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "functions", __v)?;
        }
        if let Some(__v) = &self.invariants {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "invariants", __v)?;
        }
        if let Some(__v) = &self.is_abstract {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_abstract", __v)?;
        }
        if let Some(__v) = &self.is_override {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_override", __v)?;
        }
        if let Some(__v) = &self.generic_parameter_defs {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "generic_parameter_defs",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "source_schema_id",
            &self.source_schema_id,
        )?;
        if let Some(__v) = &self.bmm_class {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_class", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "uid", &self.uid)?;
        if let Some(__v) = &self.ancestor_defs
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "ancestor_defs", __v)?;
        }
        if let Some(__v) = &self.item_names
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_names", __v)?;
        }
        if let Some(__v) = &self.item_values
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_values", __v)?;
        }
        if let Some(__v) = &self.item_documentations
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_documentations", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_enumeration::PBmmEnumerationData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "ancestor_defs",
            "ancestors",
            "bmm_class",
            "constants",
            "documentation",
            "functions",
            "generic_parameter_defs",
            "invariants",
            "is_abstract",
            "is_override",
            "item_documentations",
            "item_names",
            "item_values",
            "name",
            "properties",
            "source_schema_id",
            "uid",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
            __F14,
            __F15,
            __F16,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F2),
                            "constants" => ::core::result::Result::Ok(__Field::__F3),
                            "properties" => ::core::result::Result::Ok(__Field::__F4),
                            "functions" => ::core::result::Result::Ok(__Field::__F5),
                            "invariants" => ::core::result::Result::Ok(__Field::__F6),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F7),
                            "is_override" => ::core::result::Result::Ok(__Field::__F8),
                            "generic_parameter_defs" => ::core::result::Result::Ok(__Field::__F9),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F10),
                            "bmm_class" => ::core::result::Result::Ok(__Field::__F11),
                            "uid" => ::core::result::Result::Ok(__Field::__F12),
                            "ancestor_defs" => ::core::result::Result::Ok(__Field::__F13),
                            "item_names" => ::core::result::Result::Ok(__Field::__F14),
                            "item_values" => ::core::result::Result::Ok(__Field::__F15),
                            "item_documentations" => ::core::result::Result::Ok(__Field::__F16),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_ENUMERATION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_enumeration::PBmmEnumerationData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_ENUMERATION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<_> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<_> = None;
                let mut __s14: ::core::option::Option<_> = None;
                let mut __s15: ::core::option::Option<_> = None;
                let mut __s16: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_BMM_ENUMERATION"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("ancestors"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constants"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("properties"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("functions"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("invariants"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_abstract"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_override"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("generic_parameter_defs"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("source_schema_id"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_class"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("uid"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("ancestor_defs"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F14 => {
                            if __s14.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_names"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F15 => {
                            if __s15.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_values"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F16 => {
                            if __s16.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_documentations"),
                                );
                            }
                            __s16 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm_persistence::p_bmm_enumeration::PBmmEnumerationData {
                        documentation: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        ancestors: __s2,
                        constants: __s3.flatten(),
                        properties: __s4.flatten(),
                        functions: __s5.flatten(),
                        invariants: __s6.flatten(),
                        is_abstract: __s7.flatten(),
                        is_override: __s8.flatten(),
                        generic_parameter_defs: __s9.flatten(),
                        source_schema_id: __s10
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                        bmm_class: __s11.flatten(),
                        uid: __s12
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("uid"))?,
                        ancestor_defs: __s13,
                        item_names: __s14,
                        item_values: __s15,
                        item_documentations: __s16,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_ENUMERATION",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm_persistence::p_bmm_enumeration::PBmmEnumeration {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm_persistence::p_bmm_enumeration::PBmmEnumeration::PBmmEnumerationInteger(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_enumeration::PBmmEnumeration::PBmmEnumerationString(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_enumeration::PBmmEnumeration::PBmmEnumeration(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_enumeration::PBmmEnumeration
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "P_BMM_ENUMERATION",
            "P_BMM_ENUMERATION_INTEGER",
            "P_BMM_ENUMERATION_STRING",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_enumeration::PBmmEnumeration;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_ENUMERATION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_BMM_ENUMERATION" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_enumeration::PBmmEnumeration::PBmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_enumeration::PBmmEnumeration::PBmmEnumerationInteger(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_enumeration::PBmmEnumeration::PBmmEnumerationString(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_BMM_ENUMERATION", __other, "P_BMM_ENUMERATION, P_BMM_ENUMERATION_INTEGER, P_BMM_ENUMERATION_STRING")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "P_BMM_ENUMERATION",
                            &__other,
                            "P_BMM_ENUMERATION, P_BMM_ENUMERATION_INTEGER, P_BMM_ENUMERATION_STRING",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_enumeration::PBmmEnumeration::PBmmEnumeration(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm_persistence::p_bmm_enumeration_integer::PBmmEnumerationInteger
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.ancestors.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.constants.is_some() {
            __n += 1;
        }
        if self.properties.is_some() {
            __n += 1;
        }
        if self.functions.is_some() {
            __n += 1;
        }
        if self.invariants.is_some() {
            __n += 1;
        }
        if self.is_abstract.is_some() {
            __n += 1;
        }
        if self.is_override.is_some() {
            __n += 1;
        }
        if self.generic_parameter_defs.is_some() {
            __n += 1;
        }
        if self.bmm_class.is_some() {
            __n += 1;
        }
        if self
            .ancestor_defs
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.item_names.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.item_values.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self
            .item_documentations
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_BMM_ENUMERATION_INTEGER", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "P_BMM_ENUMERATION_INTEGER",
        )?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.ancestors
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "ancestors", __v)?;
        }
        if let Some(__v) = &self.constants {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constants", __v)?;
        }
        if let Some(__v) = &self.properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "properties", __v)?;
        }
        if let Some(__v) = &self.functions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "functions", __v)?;
        }
        if let Some(__v) = &self.invariants {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "invariants", __v)?;
        }
        if let Some(__v) = &self.is_abstract {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_abstract", __v)?;
        }
        if let Some(__v) = &self.is_override {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_override", __v)?;
        }
        if let Some(__v) = &self.generic_parameter_defs {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "generic_parameter_defs",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "source_schema_id",
            &self.source_schema_id,
        )?;
        if let Some(__v) = &self.bmm_class {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_class", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "uid", &self.uid)?;
        if let Some(__v) = &self.ancestor_defs
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "ancestor_defs", __v)?;
        }
        if let Some(__v) = &self.item_names
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_names", __v)?;
        }
        if let Some(__v) = &self.item_values
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_values", __v)?;
        }
        if let Some(__v) = &self.item_documentations
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_documentations", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_enumeration_integer::PBmmEnumerationInteger
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "ancestor_defs",
            "ancestors",
            "bmm_class",
            "constants",
            "documentation",
            "functions",
            "generic_parameter_defs",
            "invariants",
            "is_abstract",
            "is_override",
            "item_documentations",
            "item_names",
            "item_values",
            "name",
            "properties",
            "source_schema_id",
            "uid",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
            __F14,
            __F15,
            __F16,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F2),
                            "constants" => ::core::result::Result::Ok(__Field::__F3),
                            "properties" => ::core::result::Result::Ok(__Field::__F4),
                            "functions" => ::core::result::Result::Ok(__Field::__F5),
                            "invariants" => ::core::result::Result::Ok(__Field::__F6),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F7),
                            "is_override" => ::core::result::Result::Ok(__Field::__F8),
                            "generic_parameter_defs" => ::core::result::Result::Ok(__Field::__F9),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F10),
                            "bmm_class" => ::core::result::Result::Ok(__Field::__F11),
                            "uid" => ::core::result::Result::Ok(__Field::__F12),
                            "ancestor_defs" => ::core::result::Result::Ok(__Field::__F13),
                            "item_names" => ::core::result::Result::Ok(__Field::__F14),
                            "item_values" => ::core::result::Result::Ok(__Field::__F15),
                            "item_documentations" => ::core::result::Result::Ok(__Field::__F16),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_ENUMERATION_INTEGER",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm_persistence::p_bmm_enumeration_integer::PBmmEnumerationInteger;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_ENUMERATION_INTEGER` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<_> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<_> = None;
                let mut __s14: ::core::option::Option<_> = None;
                let mut __s15: ::core::option::Option<_> = None;
                let mut __s16: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "P_BMM_ENUMERATION_INTEGER",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("ancestors"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constants"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("properties"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("functions"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("invariants"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_abstract"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_override"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("generic_parameter_defs"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("source_schema_id"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_class"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("uid"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("ancestor_defs"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F14 => {
                            if __s14.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_names"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F15 => {
                            if __s15.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_values"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F16 => {
                            if __s16.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_documentations"),
                                );
                            }
                            __s16 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_enumeration_integer::PBmmEnumerationInteger {
documentation: __s0.flatten(),
name: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
ancestors: __s2,
constants: __s3.flatten(),
properties: __s4.flatten(),
functions: __s5.flatten(),
invariants: __s6.flatten(),
is_abstract: __s7.flatten(),
is_override: __s8.flatten(),
generic_parameter_defs: __s9.flatten(),
source_schema_id: __s10.flatten().ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
bmm_class: __s11.flatten(),
uid: __s12.flatten().ok_or_else(|| ::serde::de::Error::missing_field("uid"))?,
ancestor_defs: __s13,
item_names: __s14,
item_values: __s15,
item_documentations: __s16,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_ENUMERATION_INTEGER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm_persistence::p_bmm_enumeration_string::PBmmEnumerationString
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.ancestors.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.constants.is_some() {
            __n += 1;
        }
        if self.properties.is_some() {
            __n += 1;
        }
        if self.functions.is_some() {
            __n += 1;
        }
        if self.invariants.is_some() {
            __n += 1;
        }
        if self.is_abstract.is_some() {
            __n += 1;
        }
        if self.is_override.is_some() {
            __n += 1;
        }
        if self.generic_parameter_defs.is_some() {
            __n += 1;
        }
        if self.bmm_class.is_some() {
            __n += 1;
        }
        if self
            .ancestor_defs
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.item_names.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.item_values.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self
            .item_documentations
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_BMM_ENUMERATION_STRING", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "P_BMM_ENUMERATION_STRING",
        )?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.ancestors
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "ancestors", __v)?;
        }
        if let Some(__v) = &self.constants {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constants", __v)?;
        }
        if let Some(__v) = &self.properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "properties", __v)?;
        }
        if let Some(__v) = &self.functions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "functions", __v)?;
        }
        if let Some(__v) = &self.invariants {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "invariants", __v)?;
        }
        if let Some(__v) = &self.is_abstract {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_abstract", __v)?;
        }
        if let Some(__v) = &self.is_override {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_override", __v)?;
        }
        if let Some(__v) = &self.generic_parameter_defs {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "generic_parameter_defs",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "source_schema_id",
            &self.source_schema_id,
        )?;
        if let Some(__v) = &self.bmm_class {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_class", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "uid", &self.uid)?;
        if let Some(__v) = &self.ancestor_defs
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "ancestor_defs", __v)?;
        }
        if let Some(__v) = &self.item_names
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_names", __v)?;
        }
        if let Some(__v) = &self.item_values
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_values", __v)?;
        }
        if let Some(__v) = &self.item_documentations
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item_documentations", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_enumeration_string::PBmmEnumerationString
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "ancestor_defs",
            "ancestors",
            "bmm_class",
            "constants",
            "documentation",
            "functions",
            "generic_parameter_defs",
            "invariants",
            "is_abstract",
            "is_override",
            "item_documentations",
            "item_names",
            "item_values",
            "name",
            "properties",
            "source_schema_id",
            "uid",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
            __F14,
            __F15,
            __F16,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F2),
                            "constants" => ::core::result::Result::Ok(__Field::__F3),
                            "properties" => ::core::result::Result::Ok(__Field::__F4),
                            "functions" => ::core::result::Result::Ok(__Field::__F5),
                            "invariants" => ::core::result::Result::Ok(__Field::__F6),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F7),
                            "is_override" => ::core::result::Result::Ok(__Field::__F8),
                            "generic_parameter_defs" => ::core::result::Result::Ok(__Field::__F9),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F10),
                            "bmm_class" => ::core::result::Result::Ok(__Field::__F11),
                            "uid" => ::core::result::Result::Ok(__Field::__F12),
                            "ancestor_defs" => ::core::result::Result::Ok(__Field::__F13),
                            "item_names" => ::core::result::Result::Ok(__Field::__F14),
                            "item_values" => ::core::result::Result::Ok(__Field::__F15),
                            "item_documentations" => ::core::result::Result::Ok(__Field::__F16),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_ENUMERATION_STRING",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm_persistence::p_bmm_enumeration_string::PBmmEnumerationString;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_ENUMERATION_STRING` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<_> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<_> = None;
                let mut __s14: ::core::option::Option<_> = None;
                let mut __s15: ::core::option::Option<_> = None;
                let mut __s16: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "P_BMM_ENUMERATION_STRING",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("ancestors"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constants"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("properties"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("functions"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("invariants"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_abstract"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_override"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("generic_parameter_defs"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("source_schema_id"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_class"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("uid"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("ancestor_defs"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F14 => {
                            if __s14.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_names"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F15 => {
                            if __s15.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_values"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F16 => {
                            if __s16.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("item_documentations"),
                                );
                            }
                            __s16 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm_persistence::p_bmm_enumeration_string::PBmmEnumerationString {
                        documentation: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        ancestors: __s2,
                        constants: __s3.flatten(),
                        properties: __s4.flatten(),
                        functions: __s5.flatten(),
                        invariants: __s6.flatten(),
                        is_abstract: __s7.flatten(),
                        is_override: __s8.flatten(),
                        generic_parameter_defs: __s9.flatten(),
                        source_schema_id: __s10
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                        bmm_class: __s11.flatten(),
                        uid: __s12
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("uid"))?,
                        ancestor_defs: __s13,
                        item_names: __s14,
                        item_values: __s15,
                        item_documentations: __s16,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_ENUMERATION_STRING",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm_persistence::p_bmm_function::PBmmFunction {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.aliases.is_some() {
            __n += 1;
        }
        if self.is_abstract.is_some() {
            __n += 1;
        }
        if self.parameters.is_some() {
            __n += 1;
        }
        if self.pre_conditions.is_some() {
            __n += 1;
        }
        if self.post_conditions.is_some() {
            __n += 1;
        }
        if self.result.is_some() {
            __n += 1;
        }
        if self.is_nullable.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_BMM_FUNCTION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_BMM_FUNCTION")?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.aliases {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "aliases", __v)?;
        }
        if let Some(__v) = &self.is_abstract {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_abstract", __v)?;
        }
        if let Some(__v) = &self.parameters {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parameters", __v)?;
        }
        if let Some(__v) = &self.pre_conditions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "pre_conditions", __v)?;
        }
        if let Some(__v) = &self.post_conditions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "post_conditions", __v)?;
        }
        if let Some(__v) = &self.result {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "result", __v)?;
        }
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm_persistence::p_bmm_function::PBmmFunction {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "aliases",
            "documentation",
            "is_abstract",
            "is_nullable",
            "name",
            "parameters",
            "post_conditions",
            "pre_conditions",
            "result",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "aliases" => ::core::result::Result::Ok(__Field::__F2),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F3),
                            "parameters" => ::core::result::Result::Ok(__Field::__F4),
                            "pre_conditions" => ::core::result::Result::Ok(__Field::__F5),
                            "post_conditions" => ::core::result::Result::Ok(__Field::__F6),
                            "result" => ::core::result::Result::Ok(__Field::__F7),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F8),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_FUNCTION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_function::PBmmFunction;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_FUNCTION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_BMM_FUNCTION"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("aliases"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_abstract"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parameters"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("pre_conditions"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("post_conditions"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("result"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_nullable"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm_persistence::p_bmm_function::PBmmFunction {
                        documentation: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        aliases: __s2.flatten(),
                        is_abstract: __s3.flatten(),
                        parameters: __s4.flatten(),
                        pre_conditions: __s5.flatten(),
                        post_conditions: __s6.flatten(),
                        result: __s7.flatten(),
                        is_nullable: __s8.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_FUNCTION",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter::PBmmContainerFunctionParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter::PBmmGenericFunctionParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter::PBmmSingleFunctionParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter::PBmmSingleFunctionParameterOpen(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "P_BMM_CONTAINER_FUNCTION_PARAMETER",
            "P_BMM_GENERIC_FUNCTION_PARAMETER",
            "P_BMM_SINGLE_FUNCTION_PARAMETER",
            "P_BMM_SINGLE_FUNCTION_PARAMETER_OPEN",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_FUNCTION_PARAMETER` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_BMM_CONTAINER_FUNCTION_PARAMETER" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter::PBmmContainerFunctionParameter(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_GENERIC_FUNCTION_PARAMETER" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter::PBmmGenericFunctionParameter(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_FUNCTION_PARAMETER" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter::PBmmSingleFunctionParameter(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_FUNCTION_PARAMETER_OPEN" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter::PBmmSingleFunctionParameterOpen(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_BMM_FUNCTION_PARAMETER", __other, "P_BMM_CONTAINER_FUNCTION_PARAMETER, P_BMM_GENERIC_FUNCTION_PARAMETER, P_BMM_SINGLE_FUNCTION_PARAMETER, P_BMM_SINGLE_FUNCTION_PARAMETER_OPEN")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "P_BMM_FUNCTION_PARAMETER",
                            &__other,
                            "P_BMM_CONTAINER_FUNCTION_PARAMETER, P_BMM_GENERIC_FUNCTION_PARAMETER, P_BMM_SINGLE_FUNCTION_PARAMETER, P_BMM_SINGLE_FUNCTION_PARAMETER_OPEN",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "P_BMM_FUNCTION_PARAMETER",
                            "P_BMM_CONTAINER_FUNCTION_PARAMETER, P_BMM_GENERIC_FUNCTION_PARAMETER, P_BMM_SINGLE_FUNCTION_PARAMETER, P_BMM_SINGLE_FUNCTION_PARAMETER_OPEN",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm_persistence::p_bmm_generic_function_parameter::PBmmGenericFunctionParameter
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.is_nullable.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(
            __serializer,
            "P_BMM_GENERIC_FUNCTION_PARAMETER",
            __n,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "P_BMM_GENERIC_FUNCTION_PARAMETER",
        )?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_def", &self.type_def)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_generic_function_parameter::PBmmGenericFunctionParameter
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["documentation", "is_nullable", "name", "type_def"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F2),
                            "type_def" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_GENERIC_FUNCTION_PARAMETER",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_generic_function_parameter::PBmmGenericFunctionParameter;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_GENERIC_FUNCTION_PARAMETER` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "P_BMM_GENERIC_FUNCTION_PARAMETER",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_nullable"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type_def"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_generic_function_parameter::PBmmGenericFunctionParameter {
documentation: __s0.flatten(),
name: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
is_nullable: __s2.flatten(),
type_def: __s3.flatten().ok_or_else(|| ::serde::de::Error::missing_field("type_def"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_GENERIC_FUNCTION_PARAMETER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm_persistence::p_bmm_generic_parameter::PBmmGenericParameter
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.conforms_to_type.is_some() {
            __n += 1;
        }
        if self.bmm_generic_parameter.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_BMM_GENERIC_PARAMETER", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "P_BMM_GENERIC_PARAMETER",
        )?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.conforms_to_type {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "conforms_to_type", __v)?;
        }
        if let Some(__v) = &self.bmm_generic_parameter {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "bmm_generic_parameter",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_generic_parameter::PBmmGenericParameter
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "bmm_generic_parameter",
            "conforms_to_type",
            "documentation",
            "name",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "conforms_to_type" => ::core::result::Result::Ok(__Field::__F2),
                            "bmm_generic_parameter" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_GENERIC_PARAMETER",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm_persistence::p_bmm_generic_parameter::PBmmGenericParameter;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_GENERIC_PARAMETER` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "P_BMM_GENERIC_PARAMETER",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("conforms_to_type"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_generic_parameter"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm_persistence::p_bmm_generic_parameter::PBmmGenericParameter {
                        documentation: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        conforms_to_type: __s2.flatten(),
                        bmm_generic_parameter: __s3.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_GENERIC_PARAMETER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm_persistence::p_bmm_generic_property::PBmmGenericProperty
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.is_mandatory.is_some() {
            __n += 1;
        }
        if self.is_computed.is_some() {
            __n += 1;
        }
        if self.is_im_infrastructure.is_some() {
            __n += 1;
        }
        if self.is_im_runtime.is_some() {
            __n += 1;
        }
        if self.type_def.is_some() {
            __n += 1;
        }
        if self.bmm_property.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_BMM_GENERIC_PROPERTY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "P_BMM_GENERIC_PROPERTY",
        )?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.is_mandatory {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_mandatory", __v)?;
        }
        if let Some(__v) = &self.is_computed {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_computed", __v)?;
        }
        if let Some(__v) = &self.is_im_infrastructure {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_im_infrastructure", __v)?;
        }
        if let Some(__v) = &self.is_im_runtime {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_im_runtime", __v)?;
        }
        if let Some(__v) = &self.type_def {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_def", __v)?;
        }
        if let Some(__v) = &self.bmm_property {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_property", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_generic_property::PBmmGenericProperty
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "bmm_property",
            "documentation",
            "is_computed",
            "is_im_infrastructure",
            "is_im_runtime",
            "is_mandatory",
            "name",
            "type_def",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "is_mandatory" => ::core::result::Result::Ok(__Field::__F2),
                            "is_computed" => ::core::result::Result::Ok(__Field::__F3),
                            "is_im_infrastructure" => ::core::result::Result::Ok(__Field::__F4),
                            "is_im_runtime" => ::core::result::Result::Ok(__Field::__F5),
                            "type_def" => ::core::result::Result::Ok(__Field::__F6),
                            "bmm_property" => ::core::result::Result::Ok(__Field::__F7),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_GENERIC_PROPERTY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_generic_property::PBmmGenericProperty;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_GENERIC_PROPERTY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "P_BMM_GENERIC_PROPERTY",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_mandatory"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_computed"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_im_infrastructure"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_im_runtime"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type_def"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_property"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm_persistence::p_bmm_generic_property::PBmmGenericProperty {
                        documentation: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        is_mandatory: __s2.flatten(),
                        is_computed: __s3.flatten(),
                        is_im_infrastructure: __s4.flatten(),
                        is_im_runtime: __s5.flatten(),
                        type_def: __s6.flatten(),
                        bmm_property: __s7.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_GENERIC_PROPERTY",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm_persistence::p_bmm_generic_type::PBmmGenericType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.bmm_type.is_some() {
            __n += 1;
        }
        if self.value_constraint.is_some() {
            __n += 1;
        }
        if !self.generic_parameter_defs.is_empty() {
            __n += 1;
        }
        if self
            .generic_parameters
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_BMM_GENERIC_TYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_BMM_GENERIC_TYPE")?;
        if let Some(__v) = &self.bmm_type {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_type", __v)?;
        }
        if let Some(__v) = &self.value_constraint {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "value_constraint", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "root_type", &self.root_type)?;
        if !self.generic_parameter_defs.is_empty() {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "generic_parameter_defs",
                &self.generic_parameter_defs,
            )?;
        }
        if let Some(__v) = &self.generic_parameters
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "generic_parameters", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_generic_type::PBmmGenericType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "bmm_type",
            "generic_parameter_defs",
            "generic_parameters",
            "root_type",
            "value_constraint",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "bmm_type" => ::core::result::Result::Ok(__Field::__F0),
                            "value_constraint" => ::core::result::Result::Ok(__Field::__F1),
                            "root_type" => ::core::result::Result::Ok(__Field::__F2),
                            "generic_parameter_defs" => ::core::result::Result::Ok(__Field::__F3),
                            "generic_parameters" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_GENERIC_TYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_generic_type::PBmmGenericType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_GENERIC_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<_> = None;
                let mut __s4: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_BMM_GENERIC_TYPE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_type"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value_constraint"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("root_type"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("generic_parameter_defs"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("generic_parameters"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm_persistence::p_bmm_generic_type::PBmmGenericType {
                        bmm_type: __s0.flatten(),
                        value_constraint: __s1.flatten(),
                        root_type: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("root_type"))?,
                        generic_parameter_defs: __s3.unwrap_or_default(),
                        generic_parameters: __s4,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_GENERIC_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm_persistence::p_bmm_indexed_container_property::PBmmIndexedContainerProperty
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.is_mandatory.is_some() {
            __n += 1;
        }
        if self.is_computed.is_some() {
            __n += 1;
        }
        if self.is_im_infrastructure.is_some() {
            __n += 1;
        }
        if self.is_im_runtime.is_some() {
            __n += 1;
        }
        if self.type_def.is_some() {
            __n += 1;
        }
        if self.bmm_property.is_some() {
            __n += 1;
        }
        if self.cardinality.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(
            __serializer,
            "P_BMM_INDEXED_CONTAINER_PROPERTY",
            __n,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "P_BMM_INDEXED_CONTAINER_PROPERTY",
        )?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.is_mandatory {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_mandatory", __v)?;
        }
        if let Some(__v) = &self.is_computed {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_computed", __v)?;
        }
        if let Some(__v) = &self.is_im_infrastructure {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_im_infrastructure", __v)?;
        }
        if let Some(__v) = &self.is_im_runtime {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_im_runtime", __v)?;
        }
        if let Some(__v) = &self.type_def {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_def", __v)?;
        }
        if let Some(__v) = &self.bmm_property {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_property", __v)?;
        }
        if let Some(__v) = &self.cardinality {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "cardinality", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_indexed_container_property::PBmmIndexedContainerProperty
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "bmm_property",
            "cardinality",
            "documentation",
            "is_computed",
            "is_im_infrastructure",
            "is_im_runtime",
            "is_mandatory",
            "name",
            "type_def",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "is_mandatory" => ::core::result::Result::Ok(__Field::__F2),
                            "is_computed" => ::core::result::Result::Ok(__Field::__F3),
                            "is_im_infrastructure" => ::core::result::Result::Ok(__Field::__F4),
                            "is_im_runtime" => ::core::result::Result::Ok(__Field::__F5),
                            "type_def" => ::core::result::Result::Ok(__Field::__F6),
                            "bmm_property" => ::core::result::Result::Ok(__Field::__F7),
                            "cardinality" => ::core::result::Result::Ok(__Field::__F8),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_INDEXED_CONTAINER_PROPERTY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_indexed_container_property::PBmmIndexedContainerProperty;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_INDEXED_CONTAINER_PROPERTY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "P_BMM_INDEXED_CONTAINER_PROPERTY",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_mandatory"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_computed"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_im_infrastructure"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_im_runtime"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type_def"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_property"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("cardinality"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_indexed_container_property::PBmmIndexedContainerProperty {
documentation: __s0.flatten(),
name: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
is_mandatory: __s2.flatten(),
is_computed: __s3.flatten(),
is_im_infrastructure: __s4.flatten(),
is_im_runtime: __s5.flatten(),
type_def: __s6.flatten(),
bmm_property: __s7.flatten(),
cardinality: __s8.flatten(),
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_INDEXED_CONTAINER_PROPERTY",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm_persistence::p_bmm_indexed_container_type::PBmmIndexedContainerType
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.bmm_type.is_some() {
            __n += 1;
        }
        if self.type_def.is_some() {
            __n += 1;
        }
        if self.r#type.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(
            __serializer,
            "P_BMM_INDEXED_CONTAINER_TYPE",
            __n,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "P_BMM_INDEXED_CONTAINER_TYPE",
        )?;
        if let Some(__v) = &self.bmm_type {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_type", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "container_type",
            &self.container_type,
        )?;
        if let Some(__v) = &self.type_def {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_def", __v)?;
        }
        if let Some(__v) = &self.r#type {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "index_type", &self.index_type)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_indexed_container_type::PBmmIndexedContainerType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "bmm_type",
            "container_type",
            "index_type",
            "type",
            "type_def",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "bmm_type" => ::core::result::Result::Ok(__Field::__F0),
                            "container_type" => ::core::result::Result::Ok(__Field::__F1),
                            "type_def" => ::core::result::Result::Ok(__Field::__F2),
                            "type" => ::core::result::Result::Ok(__Field::__F3),
                            "index_type" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_INDEXED_CONTAINER_TYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_indexed_container_type::PBmmIndexedContainerType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_INDEXED_CONTAINER_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "P_BMM_INDEXED_CONTAINER_TYPE",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_type"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("container_type"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type_def"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("index_type"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_indexed_container_type::PBmmIndexedContainerType {
bmm_type: __s0.flatten(),
container_type: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("container_type"))?,
type_def: __s2.flatten(),
r#type: __s3.flatten(),
index_type: __s4.flatten().ok_or_else(|| ::serde::de::Error::missing_field("index_type"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_INDEXED_CONTAINER_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm_persistence::p_bmm_interface::PBmmInterface {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.functions.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_BMM_INTERFACE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_BMM_INTERFACE")?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.functions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "functions", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_interface::PBmmInterface
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["documentation", "functions", "name"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "functions" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_INTERFACE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_interface::PBmmInterface;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_INTERFACE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_BMM_INTERFACE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("functions"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm_persistence::p_bmm_interface::PBmmInterface {
                        documentation: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        functions: __s2.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_INTERFACE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmClass(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmConstant(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmContainerFunctionParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmFunction(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmGenericFunctionParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmGenericParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmGenericProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmPackage(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSingleFunctionParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSingleFunctionParameterOpen(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSingleProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSinglePropertyOpen(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "P_BMM_CLASS",
            "P_BMM_CONSTANT",
            "P_BMM_CONTAINER_FUNCTION_PARAMETER",
            "P_BMM_CONTAINER_PROPERTY",
            "P_BMM_ENUMERATION",
            "P_BMM_ENUMERATION_INTEGER",
            "P_BMM_ENUMERATION_STRING",
            "P_BMM_FUNCTION",
            "P_BMM_GENERIC_FUNCTION_PARAMETER",
            "P_BMM_GENERIC_PARAMETER",
            "P_BMM_GENERIC_PROPERTY",
            "P_BMM_INDEXED_CONTAINER_PROPERTY",
            "P_BMM_INTERFACE",
            "P_BMM_PACKAGE",
            "P_BMM_SINGLE_FUNCTION_PARAMETER",
            "P_BMM_SINGLE_FUNCTION_PARAMETER_OPEN",
            "P_BMM_SINGLE_PROPERTY",
            "P_BMM_SINGLE_PROPERTY_OPEN",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_MODEL_ELEMENT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_BMM_CLASS" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmClass(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_CONSTANT" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmConstant(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_CONTAINER_FUNCTION_PARAMETER" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmContainerFunctionParameter(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmClass(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmClass(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmClass(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_FUNCTION" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmFunction(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_GENERIC_FUNCTION_PARAMETER" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmGenericFunctionParameter(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_GENERIC_PARAMETER" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmGenericParameter(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_GENERIC_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmGenericProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INTERFACE" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmClass(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_PACKAGE" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmPackage(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_FUNCTION_PARAMETER" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSingleFunctionParameter(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_FUNCTION_PARAMETER_OPEN" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSingleFunctionParameterOpen(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSingleProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_PROPERTY_OPEN" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSinglePropertyOpen(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_BMM_MODEL_ELEMENT", __other, "P_BMM_CLASS, P_BMM_CONSTANT, P_BMM_CONTAINER_FUNCTION_PARAMETER, P_BMM_CONTAINER_PROPERTY, P_BMM_ENUMERATION, P_BMM_ENUMERATION_INTEGER, P_BMM_ENUMERATION_STRING, P_BMM_FUNCTION, P_BMM_GENERIC_FUNCTION_PARAMETER, P_BMM_GENERIC_PARAMETER, P_BMM_GENERIC_PROPERTY, P_BMM_INDEXED_CONTAINER_PROPERTY, P_BMM_INTERFACE, P_BMM_PACKAGE, P_BMM_SINGLE_FUNCTION_PARAMETER, P_BMM_SINGLE_FUNCTION_PARAMETER_OPEN, P_BMM_SINGLE_PROPERTY, P_BMM_SINGLE_PROPERTY_OPEN")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "P_BMM_MODEL_ELEMENT",
                            &__other,
                            "P_BMM_CLASS, P_BMM_CONSTANT, P_BMM_CONTAINER_FUNCTION_PARAMETER, P_BMM_CONTAINER_PROPERTY, P_BMM_ENUMERATION, P_BMM_ENUMERATION_INTEGER, P_BMM_ENUMERATION_STRING, P_BMM_FUNCTION, P_BMM_GENERIC_FUNCTION_PARAMETER, P_BMM_GENERIC_PARAMETER, P_BMM_GENERIC_PROPERTY, P_BMM_INDEXED_CONTAINER_PROPERTY, P_BMM_INTERFACE, P_BMM_PACKAGE, P_BMM_SINGLE_FUNCTION_PARAMETER, P_BMM_SINGLE_FUNCTION_PARAMETER_OPEN, P_BMM_SINGLE_PROPERTY, P_BMM_SINGLE_PROPERTY_OPEN",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "P_BMM_MODEL_ELEMENT",
                            "P_BMM_CLASS, P_BMM_CONSTANT, P_BMM_CONTAINER_FUNCTION_PARAMETER, P_BMM_CONTAINER_PROPERTY, P_BMM_ENUMERATION, P_BMM_ENUMERATION_INTEGER, P_BMM_ENUMERATION_STRING, P_BMM_FUNCTION, P_BMM_GENERIC_FUNCTION_PARAMETER, P_BMM_GENERIC_PARAMETER, P_BMM_GENERIC_PROPERTY, P_BMM_INDEXED_CONTAINER_PROPERTY, P_BMM_INTERFACE, P_BMM_PACKAGE, P_BMM_SINGLE_FUNCTION_PARAMETER, P_BMM_SINGLE_FUNCTION_PARAMETER_OPEN, P_BMM_SINGLE_PROPERTY, P_BMM_SINGLE_PROPERTY_OPEN",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm_persistence::p_bmm_open_type::PBmmOpenType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.bmm_type.is_some() {
            __n += 1;
        }
        if self.value_constraint.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_BMM_OPEN_TYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_BMM_OPEN_TYPE")?;
        if let Some(__v) = &self.bmm_type {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_type", __v)?;
        }
        if let Some(__v) = &self.value_constraint {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "value_constraint", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_open_type::PBmmOpenType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["bmm_type", "type", "value_constraint"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "bmm_type" => ::core::result::Result::Ok(__Field::__F0),
                            "value_constraint" => ::core::result::Result::Ok(__Field::__F1),
                            "type" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_OPEN_TYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_open_type::PBmmOpenType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_OPEN_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_BMM_OPEN_TYPE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_type"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value_constraint"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm_persistence::p_bmm_open_type::PBmmOpenType {
                        bmm_type: __s0.flatten(),
                        value_constraint: __s1.flatten(),
                        r#type: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_OPEN_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm_persistence::p_bmm_package::PBmmPackage {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.classes.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.bmm_package_definition.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_BMM_PACKAGE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_BMM_PACKAGE")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "packages", &self.packages)?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.classes
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "classes", __v)?;
        }
        if let Some(__v) = &self.bmm_package_definition {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "bmm_package_definition",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm_persistence::p_bmm_package::PBmmPackage {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "bmm_package_definition",
            "classes",
            "documentation",
            "name",
            "packages",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "packages" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "name" => ::core::result::Result::Ok(__Field::__F2),
                            "classes" => ::core::result::Result::Ok(__Field::__F3),
                            "bmm_package_definition" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_PACKAGE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_package::PBmmPackage;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_PACKAGE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<_> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_BMM_PACKAGE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("packages"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("classes"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_package_definition"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm_persistence::p_bmm_package::PBmmPackage {
                        packages: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("packages"))?,
                        documentation: __s1.flatten(),
                        name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        classes: __s3,
                        bmm_package_definition: __s4.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_PACKAGE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm_persistence::p_bmm_package_container::PBmmPackageContainerData
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_BMM_PACKAGE_CONTAINER", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "P_BMM_PACKAGE_CONTAINER",
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "packages", &self.packages)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_package_container::PBmmPackageContainerData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["packages"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "packages" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_PACKAGE_CONTAINER",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm_persistence::p_bmm_package_container::PBmmPackageContainerData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_PACKAGE_CONTAINER` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "P_BMM_PACKAGE_CONTAINER",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("packages"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_package_container::PBmmPackageContainerData {
packages: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("packages"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_PACKAGE_CONTAINER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm_persistence::p_bmm_package_container::PBmmPackageContainer
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmPackage(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmSchema(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmPackageContainer(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_package_container::PBmmPackageContainer
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["P_BMM_PACKAGE", "P_BMM_PACKAGE_CONTAINER", "P_BMM_SCHEMA"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm_persistence::p_bmm_package_container::PBmmPackageContainer;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_PACKAGE_CONTAINER` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_BMM_PACKAGE" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmPackage(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_PACKAGE_CONTAINER" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmPackageContainer(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SCHEMA" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmSchema(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_BMM_PACKAGE_CONTAINER", __other, "P_BMM_PACKAGE, P_BMM_PACKAGE_CONTAINER, P_BMM_SCHEMA")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "P_BMM_PACKAGE_CONTAINER",
                            &__other,
                            "P_BMM_PACKAGE, P_BMM_PACKAGE_CONTAINER, P_BMM_SCHEMA",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmPackageContainer(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm_persistence::p_bmm_property::PBmmProperty {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm_persistence::p_bmm_property::PBmmProperty::PBmmContainerProperty(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::bmm_persistence::p_bmm_property::PBmmProperty::PBmmGenericProperty(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v2_4::bmm_persistence::p_bmm_property::PBmmProperty::PBmmSingleProperty(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm_persistence::p_bmm_property::PBmmProperty::PBmmSinglePropertyOpen(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm_persistence::p_bmm_property::PBmmProperty {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "P_BMM_CONTAINER_PROPERTY",
            "P_BMM_GENERIC_PROPERTY",
            "P_BMM_INDEXED_CONTAINER_PROPERTY",
            "P_BMM_SINGLE_PROPERTY",
            "P_BMM_SINGLE_PROPERTY_OPEN",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_property::PBmmProperty;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_PROPERTY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_property::PBmmProperty::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_GENERIC_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_property::PBmmProperty::PBmmGenericProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_property::PBmmProperty::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_PROPERTY" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_property::PBmmProperty::PBmmSingleProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_PROPERTY_OPEN" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_property::PBmmProperty::PBmmSinglePropertyOpen(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_BMM_PROPERTY", __other, "P_BMM_CONTAINER_PROPERTY, P_BMM_GENERIC_PROPERTY, P_BMM_INDEXED_CONTAINER_PROPERTY, P_BMM_SINGLE_PROPERTY, P_BMM_SINGLE_PROPERTY_OPEN")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "P_BMM_PROPERTY",
                            &__other,
                            "P_BMM_CONTAINER_PROPERTY, P_BMM_GENERIC_PROPERTY, P_BMM_INDEXED_CONTAINER_PROPERTY, P_BMM_SINGLE_PROPERTY, P_BMM_SINGLE_PROPERTY_OPEN",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "P_BMM_PROPERTY",
                            "P_BMM_CONTAINER_PROPERTY, P_BMM_GENERIC_PROPERTY, P_BMM_INDEXED_CONTAINER_PROPERTY, P_BMM_SINGLE_PROPERTY, P_BMM_SINGLE_PROPERTY_OPEN",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm_persistence::p_bmm_schema::PBmmSchema {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 10usize;
        if self
            .schema_contributors
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.archetype_parent_class.is_some() {
            __n += 1;
        }
        if self.archetype_data_value_parent_class.is_some() {
            __n += 1;
        }
        if self
            .archetype_rm_closure_packages
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.archetype_visualise_descendants_of.is_some() {
            __n += 1;
        }
        if self.includes.is_some() {
            __n += 1;
        }
        if self
            .primitive_types
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self
            .class_definitions
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_BMM_SCHEMA", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_BMM_SCHEMA")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "packages", &self.packages)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_publisher",
            &self.rm_publisher,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_release", &self.rm_release)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "schema_name",
            &self.schema_name,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "schema_revision",
            &self.schema_revision,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "schema_lifecycle_state",
            &self.schema_lifecycle_state,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "schema_author",
            &self.schema_author,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "schema_description",
            &self.schema_description,
        )?;
        if let Some(__v) = &self.schema_contributors
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "schema_contributors", __v)?;
        }
        if let Some(__v) = &self.archetype_parent_class {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "archetype_parent_class",
                __v,
            )?;
        }
        if let Some(__v) = &self.archetype_data_value_parent_class {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "archetype_data_value_parent_class",
                __v,
            )?;
        }
        if let Some(__v) = &self.archetype_rm_closure_packages
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "archetype_rm_closure_packages",
                __v,
            )?;
        }
        if let Some(__v) = &self.archetype_visualise_descendants_of {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "archetype_visualise_descendants_of",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "bmm_version",
            &self.bmm_version,
        )?;
        if let Some(__v) = &self.includes {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "includes", __v)?;
        }
        if let Some(__v) = &self.primitive_types
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "primitive_types", __v)?;
        }
        if let Some(__v) = &self.class_definitions
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "class_definitions", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm_persistence::p_bmm_schema::PBmmSchema {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "archetype_data_value_parent_class",
            "archetype_parent_class",
            "archetype_rm_closure_packages",
            "archetype_visualise_descendants_of",
            "bmm_version",
            "class_definitions",
            "includes",
            "packages",
            "primitive_types",
            "rm_publisher",
            "rm_release",
            "schema_author",
            "schema_contributors",
            "schema_description",
            "schema_lifecycle_state",
            "schema_name",
            "schema_revision",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
            __F14,
            __F15,
            __F16,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "packages" => ::core::result::Result::Ok(__Field::__F0),
                            "rm_publisher" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_release" => ::core::result::Result::Ok(__Field::__F2),
                            "schema_name" => ::core::result::Result::Ok(__Field::__F3),
                            "schema_revision" => ::core::result::Result::Ok(__Field::__F4),
                            "schema_lifecycle_state" => ::core::result::Result::Ok(__Field::__F5),
                            "schema_author" => ::core::result::Result::Ok(__Field::__F6),
                            "schema_description" => ::core::result::Result::Ok(__Field::__F7),
                            "schema_contributors" => ::core::result::Result::Ok(__Field::__F8),
                            "archetype_parent_class" => ::core::result::Result::Ok(__Field::__F9),
                            "archetype_data_value_parent_class" => {
                                ::core::result::Result::Ok(__Field::__F10)
                            }
                            "archetype_rm_closure_packages" => {
                                ::core::result::Result::Ok(__Field::__F11)
                            }
                            "archetype_visualise_descendants_of" => {
                                ::core::result::Result::Ok(__Field::__F12)
                            }
                            "bmm_version" => ::core::result::Result::Ok(__Field::__F13),
                            "includes" => ::core::result::Result::Ok(__Field::__F14),
                            "primitive_types" => ::core::result::Result::Ok(__Field::__F15),
                            "class_definitions" => ::core::result::Result::Ok(__Field::__F16),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_SCHEMA",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_schema::PBmmSchema;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_SCHEMA` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<_> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<_> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s14: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s15: ::core::option::Option<_> = None;
                let mut __s16: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_BMM_SCHEMA"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("packages"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_publisher"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_release"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_name"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_revision"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_lifecycle_state"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_author"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_description"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_contributors"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("archetype_parent_class"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "archetype_data_value_parent_class",
                                    ),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "archetype_rm_closure_packages",
                                    ),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "archetype_visualise_descendants_of",
                                    ),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_version"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F14 => {
                            if __s14.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("includes"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F15 => {
                            if __s15.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("primitive_types"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F16 => {
                            if __s16.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("class_definitions"),
                                );
                            }
                            __s16 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_schema::PBmmSchema {
                    packages: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("packages"))?,
                    rm_publisher: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("rm_publisher"))?,
                    rm_release: __s2
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("rm_release"))?,
                    schema_name: __s3
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("schema_name"))?,
                    schema_revision: __s4
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("schema_revision"))?,
                    schema_lifecycle_state: __s5.flatten().ok_or_else(|| {
                        ::serde::de::Error::missing_field("schema_lifecycle_state")
                    })?,
                    schema_author: __s6
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("schema_author"))?,
                    schema_description: __s7
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("schema_description"))?,
                    schema_contributors: __s8,
                    archetype_parent_class: __s9.flatten(),
                    archetype_data_value_parent_class: __s10.flatten(),
                    archetype_rm_closure_packages: __s11,
                    archetype_visualise_descendants_of: __s12.flatten(),
                    bmm_version: __s13
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("bmm_version"))?,
                    includes: __s14.flatten(),
                    primitive_types: __s15,
                    class_definitions: __s16,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_SCHEMA",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm_persistence::p_bmm_schema_descriptor::PBmmSchemaDescriptor
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.p_schema.is_some() {
            __n += 1;
        }
        if self.schema.is_some() {
            __n += 1;
        }
        if self.includes.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.bmm_schema.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_BMM_SCHEMA_DESCRIPTOR", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "P_BMM_SCHEMA_DESCRIPTOR",
        )?;
        if let Some(__v) = &self.p_schema {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "p_schema", __v)?;
        }
        if let Some(__v) = &self.schema {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "schema", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "schema_id", &self.schema_id)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "meta_data", &self.meta_data)?;
        if let Some(__v) = &self.includes
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "includes", __v)?;
        }
        if let Some(__v) = &self.bmm_schema {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_schema", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_schema_descriptor::PBmmSchemaDescriptor
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "bmm_schema",
            "includes",
            "meta_data",
            "p_schema",
            "schema",
            "schema_id",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "p_schema" => ::core::result::Result::Ok(__Field::__F0),
                            "schema" => ::core::result::Result::Ok(__Field::__F1),
                            "schema_id" => ::core::result::Result::Ok(__Field::__F2),
                            "meta_data" => ::core::result::Result::Ok(__Field::__F3),
                            "includes" => ::core::result::Result::Ok(__Field::__F4),
                            "bmm_schema" => ::core::result::Result::Ok(__Field::__F5),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_SCHEMA_DESCRIPTOR",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm_persistence::p_bmm_schema_descriptor::PBmmSchemaDescriptor;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_SCHEMA_DESCRIPTOR` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<_> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "P_BMM_SCHEMA_DESCRIPTOR",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("p_schema"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_id"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("meta_data"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("includes"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_schema"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm_persistence::p_bmm_schema_descriptor::PBmmSchemaDescriptor {
                        p_schema: __s0.flatten(),
                        schema: __s1.flatten(),
                        schema_id: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("schema_id"))?,
                        meta_data: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("meta_data"))?,
                        includes: __s4,
                        bmm_schema: __s5.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_SCHEMA_DESCRIPTOR",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm_persistence::p_bmm_simple_type::PBmmSimpleType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.bmm_type.is_some() {
            __n += 1;
        }
        if self.value_constraint.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_BMM_SIMPLE_TYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_BMM_SIMPLE_TYPE")?;
        if let Some(__v) = &self.bmm_type {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_type", __v)?;
        }
        if let Some(__v) = &self.value_constraint {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "value_constraint", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_simple_type::PBmmSimpleType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["bmm_type", "type", "value_constraint"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "bmm_type" => ::core::result::Result::Ok(__Field::__F0),
                            "value_constraint" => ::core::result::Result::Ok(__Field::__F1),
                            "type" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_SIMPLE_TYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_simple_type::PBmmSimpleType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_SIMPLE_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_BMM_SIMPLE_TYPE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_type"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("value_constraint"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm_persistence::p_bmm_simple_type::PBmmSimpleType {
                        bmm_type: __s0.flatten(),
                        value_constraint: __s1.flatten(),
                        r#type: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_SIMPLE_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm_persistence::p_bmm_single_property::PBmmSingleProperty
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.is_mandatory.is_some() {
            __n += 1;
        }
        if self.is_computed.is_some() {
            __n += 1;
        }
        if self.is_im_infrastructure.is_some() {
            __n += 1;
        }
        if self.is_im_runtime.is_some() {
            __n += 1;
        }
        if self.type_def.is_some() {
            __n += 1;
        }
        if self.bmm_property.is_some() {
            __n += 1;
        }
        if self.r#type.is_some() {
            __n += 1;
        }
        if self.type_ref.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_BMM_SINGLE_PROPERTY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "P_BMM_SINGLE_PROPERTY",
        )?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.is_mandatory {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_mandatory", __v)?;
        }
        if let Some(__v) = &self.is_computed {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_computed", __v)?;
        }
        if let Some(__v) = &self.is_im_infrastructure {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_im_infrastructure", __v)?;
        }
        if let Some(__v) = &self.is_im_runtime {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_im_runtime", __v)?;
        }
        if let Some(__v) = &self.type_def {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_def", __v)?;
        }
        if let Some(__v) = &self.bmm_property {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_property", __v)?;
        }
        if let Some(__v) = &self.r#type {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", __v)?;
        }
        if let Some(__v) = &self.type_ref {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_ref", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_single_property::PBmmSingleProperty
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "bmm_property",
            "documentation",
            "is_computed",
            "is_im_infrastructure",
            "is_im_runtime",
            "is_mandatory",
            "name",
            "type",
            "type_def",
            "type_ref",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "is_mandatory" => ::core::result::Result::Ok(__Field::__F2),
                            "is_computed" => ::core::result::Result::Ok(__Field::__F3),
                            "is_im_infrastructure" => ::core::result::Result::Ok(__Field::__F4),
                            "is_im_runtime" => ::core::result::Result::Ok(__Field::__F5),
                            "type_def" => ::core::result::Result::Ok(__Field::__F6),
                            "bmm_property" => ::core::result::Result::Ok(__Field::__F7),
                            "type" => ::core::result::Result::Ok(__Field::__F8),
                            "type_ref" => ::core::result::Result::Ok(__Field::__F9),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_SINGLE_PROPERTY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_single_property::PBmmSingleProperty;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_SINGLE_PROPERTY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "P_BMM_SINGLE_PROPERTY",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_mandatory"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_computed"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_im_infrastructure"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_im_runtime"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type_def"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_property"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type_ref"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm_persistence::p_bmm_single_property::PBmmSingleProperty {
                        documentation: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        is_mandatory: __s2.flatten(),
                        is_computed: __s3.flatten(),
                        is_im_infrastructure: __s4.flatten(),
                        is_im_runtime: __s5.flatten(),
                        type_def: __s6.flatten(),
                        bmm_property: __s7.flatten(),
                        r#type: __s8.flatten(),
                        type_ref: __s9.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_SINGLE_PROPERTY",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm_persistence::p_bmm_single_property_open::PBmmSinglePropertyOpen
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.is_mandatory.is_some() {
            __n += 1;
        }
        if self.is_computed.is_some() {
            __n += 1;
        }
        if self.is_im_infrastructure.is_some() {
            __n += 1;
        }
        if self.is_im_runtime.is_some() {
            __n += 1;
        }
        if self.type_def.is_some() {
            __n += 1;
        }
        if self.bmm_property.is_some() {
            __n += 1;
        }
        if self.type_ref.is_some() {
            __n += 1;
        }
        if self.r#type.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_BMM_SINGLE_PROPERTY_OPEN", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "P_BMM_SINGLE_PROPERTY_OPEN",
        )?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.is_mandatory {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_mandatory", __v)?;
        }
        if let Some(__v) = &self.is_computed {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_computed", __v)?;
        }
        if let Some(__v) = &self.is_im_infrastructure {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_im_infrastructure", __v)?;
        }
        if let Some(__v) = &self.is_im_runtime {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_im_runtime", __v)?;
        }
        if let Some(__v) = &self.type_def {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_def", __v)?;
        }
        if let Some(__v) = &self.bmm_property {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "bmm_property", __v)?;
        }
        if let Some(__v) = &self.type_ref {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_ref", __v)?;
        }
        if let Some(__v) = &self.r#type {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm_persistence::p_bmm_single_property_open::PBmmSinglePropertyOpen
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "bmm_property",
            "documentation",
            "is_computed",
            "is_im_infrastructure",
            "is_im_runtime",
            "is_mandatory",
            "name",
            "type",
            "type_def",
            "type_ref",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "is_mandatory" => ::core::result::Result::Ok(__Field::__F2),
                            "is_computed" => ::core::result::Result::Ok(__Field::__F3),
                            "is_im_infrastructure" => ::core::result::Result::Ok(__Field::__F4),
                            "is_im_runtime" => ::core::result::Result::Ok(__Field::__F5),
                            "type_def" => ::core::result::Result::Ok(__Field::__F6),
                            "bmm_property" => ::core::result::Result::Ok(__Field::__F7),
                            "type_ref" => ::core::result::Result::Ok(__Field::__F8),
                            "type" => ::core::result::Result::Ok(__Field::__F9),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_SINGLE_PROPERTY_OPEN",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::bmm_persistence::p_bmm_single_property_open::PBmmSinglePropertyOpen;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_SINGLE_PROPERTY_OPEN` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "P_BMM_SINGLE_PROPERTY_OPEN",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_mandatory"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_computed"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_im_infrastructure"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_im_runtime"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type_def"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("bmm_property"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type_ref"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("type"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_single_property_open::PBmmSinglePropertyOpen {
documentation: __s0.flatten(),
name: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
is_mandatory: __s2.flatten(),
is_computed: __s3.flatten(),
is_im_infrastructure: __s4.flatten(),
is_im_runtime: __s5.flatten(),
type_def: __s6.flatten(),
bmm_property: __s7.flatten(),
type_ref: __s8.flatten(),
r#type: __s9.flatten(),
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_SINGLE_PROPERTY_OPEN",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm_persistence::p_bmm_type::PBmmType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::bmm_persistence::p_bmm_type::PBmmType::PBmmContainerType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm_persistence::p_bmm_type::PBmmType::PBmmGenericType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm_persistence::p_bmm_type::PBmmType::PBmmOpenType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::bmm_persistence::p_bmm_type::PBmmType::PBmmSimpleType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::bmm_persistence::p_bmm_type::PBmmType {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "P_BMM_CONTAINER_TYPE",
            "P_BMM_GENERIC_TYPE",
            "P_BMM_INDEXED_CONTAINER_TYPE",
            "P_BMM_OPEN_TYPE",
            "P_BMM_SIMPLE_TYPE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm_persistence::p_bmm_type::PBmmType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_TYPE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_BMM_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_type::PBmmType::PBmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_GENERIC_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_type::PBmmType::PBmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_type::PBmmType::PBmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_OPEN_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_type::PBmmType::PBmmOpenType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v2_4::bmm_persistence::p_bmm_type::PBmmType::PBmmSimpleType(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_BMM_TYPE", __other, "P_BMM_CONTAINER_TYPE, P_BMM_GENERIC_TYPE, P_BMM_INDEXED_CONTAINER_TYPE, P_BMM_OPEN_TYPE, P_BMM_SIMPLE_TYPE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "P_BMM_TYPE",
                            &__other,
                            "P_BMM_CONTAINER_TYPE, P_BMM_GENERIC_TYPE, P_BMM_INDEXED_CONTAINER_TYPE, P_BMM_OPEN_TYPE, P_BMM_SIMPLE_TYPE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "P_BMM_TYPE",
                            "P_BMM_CONTAINER_TYPE, P_BMM_GENERIC_TYPE, P_BMM_INDEXED_CONTAINER_TYPE, P_BMM_OPEN_TYPE, P_BMM_SIMPLE_TYPE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::persistence::constraint_model::p_c_archetype_root::PCArchetypeRoot
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.is_frozen.is_some() {
            __n += 1;
        }
        if self.attributes.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self
            .attribute_tuples
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_C_ARCHETYPE_ROOT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_C_ARCHETYPE_ROOT")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.is_frozen {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_frozen", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "default_value",
            &self.default_value,
        )?;
        if let Some(__v) = &self.attributes
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "attributes", __v)?;
        }
        if let Some(__v) = &self.attribute_tuples
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "attribute_tuples", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "archetype_ref",
            &self.archetype_ref,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::constraint_model::p_c_archetype_root::PCArchetypeRoot
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "archetype_ref",
            "attribute_tuples",
            "attributes",
            "default_value",
            "is_deprecated",
            "is_frozen",
            "node_id",
            "occurrences",
            "rm_type_name",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F1),
                            "node_id" => ::core::result::Result::Ok(__Field::__F2),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F3),
                            "is_frozen" => ::core::result::Result::Ok(__Field::__F4),
                            "default_value" => ::core::result::Result::Ok(__Field::__F5),
                            "attributes" => ::core::result::Result::Ok(__Field::__F6),
                            "attribute_tuples" => ::core::result::Result::Ok(__Field::__F7),
                            "archetype_ref" => ::core::result::Result::Ok(__Field::__F8),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_C_ARCHETYPE_ROOT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::constraint_model::p_c_archetype_root::PCArchetypeRoot;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_C_ARCHETYPE_ROOT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<_> = None;
                let mut __s7: ::core::option::Option<_> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_C_ARCHETYPE_ROOT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_frozen"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("default_value"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("attributes"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("attribute_tuples"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("archetype_ref"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_archetype_root::PCArchetypeRoot {
rm_type_name: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
occurrences: __s1.flatten(),
node_id: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
is_deprecated: __s3.flatten(),
is_frozen: __s4.flatten(),
default_value: __s5.flatten().ok_or_else(|| ::serde::de::Error::missing_field("default_value"))?,
attributes: __s6,
attribute_tuples: __s7,
archetype_ref: __s8.flatten().ok_or_else(|| ::serde::de::Error::missing_field("archetype_ref"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_C_ARCHETYPE_ROOT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::persistence::constraint_model::p_c_attribute::PCAttribute
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.existence.is_some() {
            __n += 1;
        }
        if self.children.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.differential_path.is_some() {
            __n += 1;
        }
        if self.cardinality.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_C_ATTRIBUTE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_C_ATTRIBUTE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_attribute_name",
            &self.rm_attribute_name,
        )?;
        if let Some(__v) = &self.existence {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "existence", __v)?;
        }
        if let Some(__v) = &self.children
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "children", __v)?;
        }
        if let Some(__v) = &self.differential_path {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "differential_path", __v)?;
        }
        if let Some(__v) = &self.cardinality {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "cardinality", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_multiple",
            &self.is_multiple,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::constraint_model::p_c_attribute::PCAttribute
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "cardinality",
            "children",
            "differential_path",
            "existence",
            "is_multiple",
            "rm_attribute_name",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_attribute_name" => ::core::result::Result::Ok(__Field::__F0),
                            "existence" => ::core::result::Result::Ok(__Field::__F1),
                            "children" => ::core::result::Result::Ok(__Field::__F2),
                            "differential_path" => ::core::result::Result::Ok(__Field::__F3),
                            "cardinality" => ::core::result::Result::Ok(__Field::__F4),
                            "is_multiple" => ::core::result::Result::Ok(__Field::__F5),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_C_ATTRIBUTE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::aom2::persistence::constraint_model::p_c_attribute::PCAttribute;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_C_ATTRIBUTE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<_> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_C_ATTRIBUTE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_attribute_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("existence"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("children"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("differential_path"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("cardinality"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_multiple"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::persistence::constraint_model::p_c_attribute::PCAttribute {
                        rm_attribute_name: __s0.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("rm_attribute_name")
                        })?,
                        existence: __s1.flatten(),
                        children: __s2,
                        differential_path: __s3.flatten(),
                        cardinality: __s4.flatten(),
                        is_multiple: __s5
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_multiple"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_C_ATTRIBUTE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::persistence::constraint_model::p_c_attribute_tuple::PCAttributeTuple
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.members.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_C_ATTRIBUTE_TUPLE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_C_ATTRIBUTE_TUPLE")?;
        if let Some(__v) = &self.members
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "members", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::constraint_model::p_c_attribute_tuple::PCAttributeTuple
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["members"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "members" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_C_ATTRIBUTE_TUPLE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::constraint_model::p_c_attribute_tuple::PCAttributeTuple;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_C_ATTRIBUTE_TUPLE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_C_ATTRIBUTE_TUPLE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("members"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_attribute_tuple::PCAttributeTuple {
members: __s0,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_C_ATTRIBUTE_TUPLE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::persistence::primitive::p_c_boolean::PCBoolean {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.is_frozen.is_some() {
            __n += 1;
        }
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.is_enumerated_type_constraint.is_some() {
            __n += 1;
        }
        if self.constraint.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_C_BOOLEAN", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_C_BOOLEAN")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.is_frozen {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_frozen", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "default_value",
            &self.default_value,
        )?;
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.is_enumerated_type_constraint {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_enumerated_type_constraint",
                __v,
            )?;
        }
        if let Some(__v) = &self.constraint
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constraint", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::primitive::p_c_boolean::PCBoolean
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "assumed_value",
            "constraint",
            "default_value",
            "is_deprecated",
            "is_enumerated_type_constraint",
            "is_frozen",
            "node_id",
            "occurrences",
            "rm_type_name",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F1),
                            "node_id" => ::core::result::Result::Ok(__Field::__F2),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F3),
                            "is_frozen" => ::core::result::Result::Ok(__Field::__F4),
                            "default_value" => ::core::result::Result::Ok(__Field::__F5),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F6),
                            "is_enumerated_type_constraint" => {
                                ::core::result::Result::Ok(__Field::__F7)
                            }
                            "constraint" => ::core::result::Result::Ok(__Field::__F8),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_C_BOOLEAN",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::primitive::p_c_boolean::PCBoolean;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_C_BOOLEAN` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_C_BOOLEAN"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_frozen"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("default_value"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "is_enumerated_type_constraint",
                                    ),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constraint"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::persistence::primitive::p_c_boolean::PCBoolean {
                        rm_type_name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
                        occurrences: __s1.flatten(),
                        node_id: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
                        is_deprecated: __s3.flatten(),
                        is_frozen: __s4.flatten(),
                        default_value: __s5
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("default_value"))?,
                        assumed_value: __s6.flatten(),
                        is_enumerated_type_constraint: __s7.flatten(),
                        constraint: __s8,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_C_BOOLEAN",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::persistence::constraint_model::p_c_complex_object::PCComplexObjectData
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 4usize;
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.is_frozen.is_some() {
            __n += 1;
        }
        if self.attributes.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self
            .attribute_tuples
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_C_COMPLEX_OBJECT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_C_COMPLEX_OBJECT")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.is_frozen {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_frozen", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "default_value",
            &self.default_value,
        )?;
        if let Some(__v) = &self.attributes
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "attributes", __v)?;
        }
        if let Some(__v) = &self.attribute_tuples
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "attribute_tuples", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::constraint_model::p_c_complex_object::PCComplexObjectData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "attribute_tuples",
            "attributes",
            "default_value",
            "is_deprecated",
            "is_frozen",
            "node_id",
            "occurrences",
            "rm_type_name",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F1),
                            "node_id" => ::core::result::Result::Ok(__Field::__F2),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F3),
                            "is_frozen" => ::core::result::Result::Ok(__Field::__F4),
                            "default_value" => ::core::result::Result::Ok(__Field::__F5),
                            "attributes" => ::core::result::Result::Ok(__Field::__F6),
                            "attribute_tuples" => ::core::result::Result::Ok(__Field::__F7),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_C_COMPLEX_OBJECT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::constraint_model::p_c_complex_object::PCComplexObjectData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_C_COMPLEX_OBJECT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<_> = None;
                let mut __s7: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_C_COMPLEX_OBJECT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_frozen"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("default_value"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("attributes"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("attribute_tuples"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_complex_object::PCComplexObjectData {
rm_type_name: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
occurrences: __s1.flatten(),
node_id: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
is_deprecated: __s3.flatten(),
is_frozen: __s4.flatten(),
default_value: __s5.flatten().ok_or_else(|| ::serde::de::Error::missing_field("default_value"))?,
attributes: __s6,
attribute_tuples: __s7,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_C_COMPLEX_OBJECT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::persistence::constraint_model::p_c_complex_object::PCComplexObject
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::aom2::persistence::constraint_model::p_c_complex_object::PCComplexObject::PCArchetypeRoot(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::constraint_model::p_c_complex_object::PCComplexObject::PCComplexObject(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::constraint_model::p_c_complex_object::PCComplexObject
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["P_C_ARCHETYPE_ROOT", "P_C_COMPLEX_OBJECT"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::constraint_model::p_c_complex_object::PCComplexObject;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_C_COMPLEX_OBJECT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_C_ARCHETYPE_ROOT" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_complex_object::PCComplexObject::PCArchetypeRoot(::serde::Deserialize::deserialize(__rest)?)),
"P_C_COMPLEX_OBJECT" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_complex_object::PCComplexObject::PCComplexObject(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_C_COMPLEX_OBJECT", __other, "P_C_ARCHETYPE_ROOT, P_C_COMPLEX_OBJECT")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "P_C_COMPLEX_OBJECT",
                            &__other,
                            "P_C_ARCHETYPE_ROOT, P_C_COMPLEX_OBJECT",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_complex_object::PCComplexObject::PCComplexObject(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::persistence::constraint_model::p_c_complex_object_proxy::PCComplexObjectProxy {
fn serialize<__S: ::serde::Serializer>(&self, __serializer: __S) -> ::core::result::Result<__S::Ok, __S::Error> {
let mut __n = 4usize;
if self.occurrences.is_some() { __n += 1; }
if self.is_deprecated.is_some() { __n += 1; }
let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_C_COMPLEX_OBJECT_PROXY", __n)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_C_COMPLEX_OBJECT_PROXY")?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_type_name", &self.rm_type_name)?;
if let Some(__v) = &self.occurrences { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?; }
::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
if let Some(__v) = &self.is_deprecated { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?; }
::serde::ser::SerializeStruct::serialize_field(&mut __st, "target_path", &self.target_path)?;
::serde::ser::SerializeStruct::end(__st)
}
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::aom2::persistence::constraint_model::p_c_complex_object_proxy::PCComplexObjectProxy {
fn deserialize<__D: ::serde::Deserializer<'de>>(__deserializer: __D) -> ::core::result::Result<Self, __D::Error> {
const __FIELDS: &[&str] = &["is_deprecated", "node_id", "occurrences", "rm_type_name", "target_path"];
enum __Field { __Type, __F0, __F1, __F2, __F3, __F4, }
impl<'de> ::serde::Deserialize<'de> for __Field {
fn deserialize<__D: ::serde::Deserializer<'de>>(__deserializer: __D) -> ::core::result::Result<Self, __D::Error> {
struct __KeyVisitor;
impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
type Value = __Field;
fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
__f.write_str("an object member name")
}
fn visit_str<__E: ::serde::de::Error>(self, __v: &str) -> ::core::result::Result<__Field, __E> {
match __v {
"_type" => ::core::result::Result::Ok(__Field::__Type),
"rm_type_name" => ::core::result::Result::Ok(__Field::__F0),
"occurrences" => ::core::result::Result::Ok(__Field::__F1),
"node_id" => ::core::result::Result::Ok(__Field::__F2),
"is_deprecated" => ::core::result::Result::Ok(__Field::__F3),
"target_path" => ::core::result::Result::Ok(__Field::__F4),
_ => ::core::result::Result::Err(::openehr_base::serde_support::unknown_field(__v, "P_C_COMPLEX_OBJECT_PROXY", __FIELDS)),
}
}
}
::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
}
}
struct __Visitor;
impl<'de> ::serde::de::Visitor<'de> for __Visitor {
type Value = crate::v2_4::aom2::persistence::constraint_model::p_c_complex_object_proxy::PCComplexObjectProxy;
fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
__f.write_str("an openEHR `P_C_COMPLEX_OBJECT_PROXY` object")
}
fn visit_map<__A: ::serde::de::MapAccess<'de>>(self, mut __map: __A) -> ::core::result::Result<Self::Value, __A::Error> {
let mut __seen_type = false;
let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
 match __key {
__Field::__Type => {
if __seen_type { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("_type")); }
__seen_type = true;
::serde::de::MapAccess::next_value_seed(&mut __map, ::openehr_base::serde_support::ExpectedType("P_C_COMPLEX_OBJECT_PROXY"))?;
}
__Field::__F0 => {
if __s0.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("rm_type_name")); }
__s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F1 => {
if __s1.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("occurrences")); }
__s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F2 => {
if __s2.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("node_id")); }
__s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F3 => {
if __s3.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("is_deprecated")); }
__s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F4 => {
if __s4.is_some() { return ::core::result::Result::Err(::serde::de::Error::duplicate_field("target_path")); }
__s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
}
}
::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_complex_object_proxy::PCComplexObjectProxy {
rm_type_name: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
occurrences: __s1.flatten(),
node_id: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
is_deprecated: __s3.flatten(),
target_path: __s4.flatten().ok_or_else(|| ::serde::de::Error::missing_field("target_path"))?,
})
}
}
::serde::Deserializer::deserialize_struct(__deserializer, "P_C_COMPLEX_OBJECT_PROXY", __FIELDS, __Visitor)
}
}

impl ::serde::Serialize for crate::v2_4::aom2::persistence::primitive::p_c_date::PCDate {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_C_DATE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_C_DATE")?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::primitive::p_c_date::PCDate
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[];
        enum __Field {
            __Type,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v, "P_C_DATE", __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::primitive::p_c_date::PCDate;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_C_DATE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_C_DATE"),
                            )?;
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::persistence::primitive::p_c_date::PCDate {},
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "P_C_DATE", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::persistence::primitive::p_c_date_time::PCDateTime {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_C_DATE_TIME", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_C_DATE_TIME")?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::primitive::p_c_date_time::PCDateTime
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[];
        enum __Field {
            __Type,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_C_DATE_TIME",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::primitive::p_c_date_time::PCDateTime;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_C_DATE_TIME` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_C_DATE_TIME"),
                            )?;
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::persistence::primitive::p_c_date_time::PCDateTime {},
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_C_DATE_TIME",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::persistence::constraint_model::p_c_defined_object::PCDefinedObject
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::aom2::persistence::constraint_model::p_c_defined_object::PCDefinedObject::PCBoolean(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::constraint_model::p_c_defined_object::PCDefinedObject::PCComplexObject(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::constraint_model::p_c_defined_object::PCDefinedObject::PCString(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::constraint_model::p_c_defined_object::PCDefinedObject::PCTerminologyCode(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::constraint_model::p_c_defined_object::PCDefinedObject
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "P_C_ARCHETYPE_ROOT",
            "P_C_BOOLEAN",
            "P_C_COMPLEX_OBJECT",
            "P_C_STRING",
            "P_C_TERMINOLOGY_CODE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::constraint_model::p_c_defined_object::PCDefinedObject;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_C_DEFINED_OBJECT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_C_ARCHETYPE_ROOT" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_defined_object::PCDefinedObject::PCComplexObject(::serde::Deserialize::deserialize(__rest)?)),
"P_C_BOOLEAN" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_defined_object::PCDefinedObject::PCBoolean(::serde::Deserialize::deserialize(__rest)?)),
"P_C_COMPLEX_OBJECT" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_defined_object::PCDefinedObject::PCComplexObject(::serde::Deserialize::deserialize(__rest)?)),
"P_C_STRING" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_defined_object::PCDefinedObject::PCString(::serde::Deserialize::deserialize(__rest)?)),
"P_C_TERMINOLOGY_CODE" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_defined_object::PCDefinedObject::PCTerminologyCode(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_C_DEFINED_OBJECT", __other, "P_C_ARCHETYPE_ROOT, P_C_BOOLEAN, P_C_COMPLEX_OBJECT, P_C_STRING, P_C_TERMINOLOGY_CODE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "P_C_DEFINED_OBJECT",
                            &__other,
                            "P_C_ARCHETYPE_ROOT, P_C_BOOLEAN, P_C_COMPLEX_OBJECT, P_C_STRING, P_C_TERMINOLOGY_CODE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "P_C_DEFINED_OBJECT",
                            "P_C_ARCHETYPE_ROOT, P_C_BOOLEAN, P_C_COMPLEX_OBJECT, P_C_STRING, P_C_TERMINOLOGY_CODE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::persistence::primitive::p_c_duration::PCDuration {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_C_DURATION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_C_DURATION")?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::primitive::p_c_duration::PCDuration
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[];
        enum __Field {
            __Type,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_C_DURATION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::primitive::p_c_duration::PCDuration;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_C_DURATION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_C_DURATION"),
                            )?;
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::persistence::primitive::p_c_duration::PCDuration {},
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_C_DURATION",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::persistence::primitive::p_c_integer::PCInteger {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_C_INTEGER", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_C_INTEGER")?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::primitive::p_c_integer::PCInteger
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[];
        enum __Field {
            __Type,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_C_INTEGER",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::primitive::p_c_integer::PCInteger;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_C_INTEGER` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_C_INTEGER"),
                            )?;
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::persistence::primitive::p_c_integer::PCInteger {},
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_C_INTEGER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::persistence::constraint_model::p_c_object::PCObject {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::aom2::persistence::constraint_model::p_c_object::PCObject::PArchetypeSlot(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::constraint_model::p_c_object::PCObject::PCBoolean(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::constraint_model::p_c_object::PCObject::PCComplexObject(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::constraint_model::p_c_object::PCObject::PCComplexObjectProxy(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::constraint_model::p_c_object::PCObject::PCString(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::constraint_model::p_c_object::PCObject::PCTerminologyCode(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::constraint_model::p_c_object::PCObject
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "P_ARCHETYPE_SLOT",
            "P_C_ARCHETYPE_ROOT",
            "P_C_BOOLEAN",
            "P_C_COMPLEX_OBJECT",
            "P_C_COMPLEX_OBJECT_PROXY",
            "P_C_STRING",
            "P_C_TERMINOLOGY_CODE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::constraint_model::p_c_object::PCObject;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_C_OBJECT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_ARCHETYPE_SLOT" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_object::PCObject::PArchetypeSlot(::serde::Deserialize::deserialize(__rest)?)),
"P_C_ARCHETYPE_ROOT" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_object::PCObject::PCComplexObject(::serde::Deserialize::deserialize(__rest)?)),
"P_C_BOOLEAN" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_object::PCObject::PCBoolean(::serde::Deserialize::deserialize(__rest)?)),
"P_C_COMPLEX_OBJECT" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_object::PCObject::PCComplexObject(::serde::Deserialize::deserialize(__rest)?)),
"P_C_COMPLEX_OBJECT_PROXY" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_object::PCObject::PCComplexObjectProxy(::serde::Deserialize::deserialize(__rest)?)),
"P_C_STRING" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_object::PCObject::PCString(::serde::Deserialize::deserialize(__rest)?)),
"P_C_TERMINOLOGY_CODE" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_object::PCObject::PCTerminologyCode(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_C_OBJECT", __other, "P_ARCHETYPE_SLOT, P_C_ARCHETYPE_ROOT, P_C_BOOLEAN, P_C_COMPLEX_OBJECT, P_C_COMPLEX_OBJECT_PROXY, P_C_STRING, P_C_TERMINOLOGY_CODE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "P_C_OBJECT",
                            &__other,
                            "P_ARCHETYPE_SLOT, P_C_ARCHETYPE_ROOT, P_C_BOOLEAN, P_C_COMPLEX_OBJECT, P_C_COMPLEX_OBJECT_PROXY, P_C_STRING, P_C_TERMINOLOGY_CODE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "P_C_OBJECT",
                            "P_ARCHETYPE_SLOT, P_C_ARCHETYPE_ROOT, P_C_BOOLEAN, P_C_COMPLEX_OBJECT, P_C_COMPLEX_OBJECT_PROXY, P_C_STRING, P_C_TERMINOLOGY_CODE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::persistence::constraint_model::p_c_primitive_object::PCPrimitiveObject
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::aom2::persistence::constraint_model::p_c_primitive_object::PCPrimitiveObject::PCBoolean(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::constraint_model::p_c_primitive_object::PCPrimitiveObject::PCString(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::aom2::persistence::constraint_model::p_c_primitive_object::PCPrimitiveObject::PCTerminologyCode(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::constraint_model::p_c_primitive_object::PCPrimitiveObject
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["P_C_BOOLEAN", "P_C_STRING", "P_C_TERMINOLOGY_CODE"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::constraint_model::p_c_primitive_object::PCPrimitiveObject;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_C_PRIMITIVE_OBJECT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_C_BOOLEAN" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_primitive_object::PCPrimitiveObject::PCBoolean(::serde::Deserialize::deserialize(__rest)?)),
"P_C_STRING" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_primitive_object::PCPrimitiveObject::PCString(::serde::Deserialize::deserialize(__rest)?)),
"P_C_TERMINOLOGY_CODE" => ::core::result::Result::Ok(crate::v2_4::aom2::persistence::constraint_model::p_c_primitive_object::PCPrimitiveObject::PCTerminologyCode(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("P_C_PRIMITIVE_OBJECT", __other, "P_C_BOOLEAN, P_C_STRING, P_C_TERMINOLOGY_CODE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "P_C_PRIMITIVE_OBJECT",
                            &__other,
                            "P_C_BOOLEAN, P_C_STRING, P_C_TERMINOLOGY_CODE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "P_C_PRIMITIVE_OBJECT",
                            "P_C_BOOLEAN, P_C_STRING, P_C_TERMINOLOGY_CODE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::persistence::primitive::p_c_real::PCReal {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_C_REAL", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_C_REAL")?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::primitive::p_c_real::PCReal
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[];
        enum __Field {
            __Type,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v, "P_C_REAL", __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::primitive::p_c_real::PCReal;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_C_REAL` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_C_REAL"),
                            )?;
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::persistence::primitive::p_c_real::PCReal {},
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "P_C_REAL", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::persistence::primitive::p_c_string::PCString {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.is_frozen.is_some() {
            __n += 1;
        }
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.is_enumerated_type_constraint.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_C_STRING", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_C_STRING")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.is_frozen {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_frozen", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "default_value",
            &self.default_value,
        )?;
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.is_enumerated_type_constraint {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_enumerated_type_constraint",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constraint", &self.constraint)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::primitive::p_c_string::PCString
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "assumed_value",
            "constraint",
            "default_value",
            "is_deprecated",
            "is_enumerated_type_constraint",
            "is_frozen",
            "node_id",
            "occurrences",
            "rm_type_name",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F1),
                            "node_id" => ::core::result::Result::Ok(__Field::__F2),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F3),
                            "is_frozen" => ::core::result::Result::Ok(__Field::__F4),
                            "default_value" => ::core::result::Result::Ok(__Field::__F5),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F6),
                            "is_enumerated_type_constraint" => {
                                ::core::result::Result::Ok(__Field::__F7)
                            }
                            "constraint" => ::core::result::Result::Ok(__Field::__F8),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_C_STRING",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::primitive::p_c_string::PCString;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_C_STRING` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_C_STRING"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_frozen"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("default_value"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "is_enumerated_type_constraint",
                                    ),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constraint"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::persistence::primitive::p_c_string::PCString {
                        rm_type_name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
                        occurrences: __s1.flatten(),
                        node_id: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
                        is_deprecated: __s3.flatten(),
                        is_frozen: __s4.flatten(),
                        default_value: __s5
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("default_value"))?,
                        assumed_value: __s6.flatten(),
                        is_enumerated_type_constraint: __s7.flatten(),
                        constraint: __s8
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("constraint"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "P_C_STRING", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::persistence::primitive::p_c_terminology_code::PCTerminologyCode
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.occurrences.is_some() {
            __n += 1;
        }
        if self.is_deprecated.is_some() {
            __n += 1;
        }
        if self.is_frozen.is_some() {
            __n += 1;
        }
        if self.assumed_value.is_some() {
            __n += 1;
        }
        if self.is_enumerated_type_constraint.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_C_TERMINOLOGY_CODE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_C_TERMINOLOGY_CODE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "rm_type_name",
            &self.rm_type_name,
        )?;
        if let Some(__v) = &self.occurrences {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "occurrences", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "node_id", &self.node_id)?;
        if let Some(__v) = &self.is_deprecated {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_deprecated", __v)?;
        }
        if let Some(__v) = &self.is_frozen {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_frozen", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "default_value",
            &self.default_value,
        )?;
        if let Some(__v) = &self.assumed_value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "assumed_value", __v)?;
        }
        if let Some(__v) = &self.is_enumerated_type_constraint {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_enumerated_type_constraint",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constraint", &self.constraint)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::primitive::p_c_terminology_code::PCTerminologyCode
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "assumed_value",
            "constraint",
            "default_value",
            "is_deprecated",
            "is_enumerated_type_constraint",
            "is_frozen",
            "node_id",
            "occurrences",
            "rm_type_name",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "occurrences" => ::core::result::Result::Ok(__Field::__F1),
                            "node_id" => ::core::result::Result::Ok(__Field::__F2),
                            "is_deprecated" => ::core::result::Result::Ok(__Field::__F3),
                            "is_frozen" => ::core::result::Result::Ok(__Field::__F4),
                            "default_value" => ::core::result::Result::Ok(__Field::__F5),
                            "assumed_value" => ::core::result::Result::Ok(__Field::__F6),
                            "is_enumerated_type_constraint" => {
                                ::core::result::Result::Ok(__Field::__F7)
                            }
                            "constraint" => ::core::result::Result::Ok(__Field::__F8),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_C_TERMINOLOGY_CODE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::aom2::persistence::primitive::p_c_terminology_code::PCTerminologyCode;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_C_TERMINOLOGY_CODE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_C_TERMINOLOGY_CODE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_type_name"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("occurrences"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("node_id"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_deprecated"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_frozen"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("default_value"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("assumed_value"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field(
                                        "is_enumerated_type_constraint",
                                    ),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("constraint"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::aom2::persistence::primitive::p_c_terminology_code::PCTerminologyCode {
rm_type_name: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("rm_type_name"))?,
occurrences: __s1.flatten(),
node_id: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("node_id"))?,
is_deprecated: __s3.flatten(),
is_frozen: __s4.flatten(),
default_value: __s5.flatten().ok_or_else(|| ::serde::de::Error::missing_field("default_value"))?,
assumed_value: __s6.flatten(),
is_enumerated_type_constraint: __s7.flatten(),
constraint: __s8.flatten().ok_or_else(|| ::serde::de::Error::missing_field("constraint"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_C_TERMINOLOGY_CODE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::persistence::primitive::p_c_time::PCTime {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_C_TIME", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_C_TIME")?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::primitive::p_c_time::PCTime
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[];
        enum __Field {
            __Type,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v, "P_C_TIME", __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::primitive::p_c_time::PCTime;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_C_TIME` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_C_TIME"),
                            )?;
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::persistence::primitive::p_c_time::PCTime {},
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "P_C_TIME", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::persistence::archetype::p_operational_template::POperationalTemplate
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 10usize;
        if self.parent_archetype_id.is_some() {
            __n += 1;
        }
        if self.rules.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.uid.is_some() {
            __n += 1;
        }
        if self.description.is_some() {
            __n += 1;
        }
        if self.is_controlled.is_some() {
            __n += 1;
        }
        if self.annotations.is_some() {
            __n += 1;
        }
        if self
            .translations
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.adl_version.is_some() {
            __n += 1;
        }
        if self.component_terminologies.is_some() {
            __n += 1;
        }
        if self.terminology_extracts.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "P_OPERATIONAL_TEMPLATE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "P_OPERATIONAL_TEMPLATE",
        )?;
        if let Some(__v) = &self.parent_archetype_id {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent_archetype_id", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "archetype_id",
            &self.archetype_id,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_differential",
            &self.is_differential,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", &self.definition)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "terminology",
            &self.terminology,
        )?;
        if let Some(__v) = &self.rules
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rules", __v)?;
        }
        if let Some(__v) = &self.uid {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "uid", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "original_language",
            &self.original_language,
        )?;
        if let Some(__v) = &self.description {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "description", __v)?;
        }
        if let Some(__v) = &self.is_controlled {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_controlled", __v)?;
        }
        if let Some(__v) = &self.annotations {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "annotations", __v)?;
        }
        if let Some(__v) = &self.translations
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "translations", __v)?;
        }
        if let Some(__v) = &self.adl_version {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "adl_version", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "build_uid", &self.build_uid)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_release", &self.rm_release)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_generated",
            &self.is_generated,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "other_meta_data",
            &self.other_meta_data,
        )?;
        if let Some(__v) = &self.component_terminologies {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "component_terminologies",
                __v,
            )?;
        }
        if let Some(__v) = &self.terminology_extracts {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "terminology_extracts", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::archetype::p_operational_template::POperationalTemplate
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "adl_version",
            "annotations",
            "archetype_id",
            "build_uid",
            "component_terminologies",
            "definition",
            "description",
            "is_controlled",
            "is_differential",
            "is_generated",
            "original_language",
            "other_meta_data",
            "parent_archetype_id",
            "rm_release",
            "rules",
            "terminology",
            "terminology_extracts",
            "translations",
            "uid",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
            __F14,
            __F15,
            __F16,
            __F17,
            __F18,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent_archetype_id" => ::core::result::Result::Ok(__Field::__F0),
                            "archetype_id" => ::core::result::Result::Ok(__Field::__F1),
                            "is_differential" => ::core::result::Result::Ok(__Field::__F2),
                            "definition" => ::core::result::Result::Ok(__Field::__F3),
                            "terminology" => ::core::result::Result::Ok(__Field::__F4),
                            "rules" => ::core::result::Result::Ok(__Field::__F5),
                            "uid" => ::core::result::Result::Ok(__Field::__F6),
                            "original_language" => ::core::result::Result::Ok(__Field::__F7),
                            "description" => ::core::result::Result::Ok(__Field::__F8),
                            "is_controlled" => ::core::result::Result::Ok(__Field::__F9),
                            "annotations" => ::core::result::Result::Ok(__Field::__F10),
                            "translations" => ::core::result::Result::Ok(__Field::__F11),
                            "adl_version" => ::core::result::Result::Ok(__Field::__F12),
                            "build_uid" => ::core::result::Result::Ok(__Field::__F13),
                            "rm_release" => ::core::result::Result::Ok(__Field::__F14),
                            "is_generated" => ::core::result::Result::Ok(__Field::__F15),
                            "other_meta_data" => ::core::result::Result::Ok(__Field::__F16),
                            "component_terminologies" => ::core::result::Result::Ok(__Field::__F17),
                            "terminology_extracts" => ::core::result::Result::Ok(__Field::__F18),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_OPERATIONAL_TEMPLATE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::archetype::p_operational_template::POperationalTemplate;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_OPERATIONAL_TEMPLATE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<_> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s14: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s15: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s16: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s17: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s18: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "P_OPERATIONAL_TEMPLATE",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent_archetype_id"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("archetype_id"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_differential"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("definition"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("terminology"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rules"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("uid"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("original_language"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("description"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_controlled"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("annotations"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("translations"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("adl_version"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("build_uid"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F14 => {
                            if __s14.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_release"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F15 => {
                            if __s15.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_generated"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F16 => {
                            if __s16.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("other_meta_data"),
                                );
                            }
                            __s16 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F17 => {
                            if __s17.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("component_terminologies"),
                                );
                            }
                            __s17 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F18 => {
                            if __s18.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("terminology_extracts"),
                                );
                            }
                            __s18 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::aom2::persistence::archetype::p_operational_template::POperationalTemplate {
parent_archetype_id: __s0.flatten(),
archetype_id: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("archetype_id"))?,
is_differential: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("is_differential"))?,
definition: __s3.flatten().ok_or_else(|| ::serde::de::Error::missing_field("definition"))?,
terminology: __s4.flatten().ok_or_else(|| ::serde::de::Error::missing_field("terminology"))?,
rules: __s5,
uid: __s6.flatten(),
original_language: __s7.flatten().ok_or_else(|| ::serde::de::Error::missing_field("original_language"))?,
description: __s8.flatten(),
is_controlled: __s9.flatten(),
annotations: __s10.flatten(),
translations: __s11,
adl_version: __s12.flatten(),
build_uid: __s13.flatten().ok_or_else(|| ::serde::de::Error::missing_field("build_uid"))?,
rm_release: __s14.flatten().ok_or_else(|| ::serde::de::Error::missing_field("rm_release"))?,
is_generated: __s15.flatten().ok_or_else(|| ::serde::de::Error::missing_field("is_generated"))?,
other_meta_data: __s16.flatten().ok_or_else(|| ::serde::de::Error::missing_field("other_meta_data"))?,
component_terminologies: __s17.flatten(),
terminology_extracts: __s18.flatten(),
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_OPERATIONAL_TEMPLATE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::persistence::archetype::p_template::PTemplate {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 10usize;
        if self.parent_archetype_id.is_some() {
            __n += 1;
        }
        if self.rules.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.uid.is_some() {
            __n += 1;
        }
        if self.description.is_some() {
            __n += 1;
        }
        if self.is_controlled.is_some() {
            __n += 1;
        }
        if self.annotations.is_some() {
            __n += 1;
        }
        if self
            .translations
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.adl_version.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_TEMPLATE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_TEMPLATE")?;
        if let Some(__v) = &self.parent_archetype_id {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent_archetype_id", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "archetype_id",
            &self.archetype_id,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_differential",
            &self.is_differential,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", &self.definition)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "terminology",
            &self.terminology,
        )?;
        if let Some(__v) = &self.rules
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rules", __v)?;
        }
        if let Some(__v) = &self.uid {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "uid", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "original_language",
            &self.original_language,
        )?;
        if let Some(__v) = &self.description {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "description", __v)?;
        }
        if let Some(__v) = &self.is_controlled {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_controlled", __v)?;
        }
        if let Some(__v) = &self.annotations {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "annotations", __v)?;
        }
        if let Some(__v) = &self.translations
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "translations", __v)?;
        }
        if let Some(__v) = &self.adl_version {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "adl_version", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "build_uid", &self.build_uid)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_release", &self.rm_release)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_generated",
            &self.is_generated,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "other_meta_data",
            &self.other_meta_data,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::persistence::archetype::p_template::PTemplate
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "adl_version",
            "annotations",
            "archetype_id",
            "build_uid",
            "definition",
            "description",
            "is_controlled",
            "is_differential",
            "is_generated",
            "original_language",
            "other_meta_data",
            "parent_archetype_id",
            "rm_release",
            "rules",
            "terminology",
            "translations",
            "uid",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
            __F14,
            __F15,
            __F16,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent_archetype_id" => ::core::result::Result::Ok(__Field::__F0),
                            "archetype_id" => ::core::result::Result::Ok(__Field::__F1),
                            "is_differential" => ::core::result::Result::Ok(__Field::__F2),
                            "definition" => ::core::result::Result::Ok(__Field::__F3),
                            "terminology" => ::core::result::Result::Ok(__Field::__F4),
                            "rules" => ::core::result::Result::Ok(__Field::__F5),
                            "uid" => ::core::result::Result::Ok(__Field::__F6),
                            "original_language" => ::core::result::Result::Ok(__Field::__F7),
                            "description" => ::core::result::Result::Ok(__Field::__F8),
                            "is_controlled" => ::core::result::Result::Ok(__Field::__F9),
                            "annotations" => ::core::result::Result::Ok(__Field::__F10),
                            "translations" => ::core::result::Result::Ok(__Field::__F11),
                            "adl_version" => ::core::result::Result::Ok(__Field::__F12),
                            "build_uid" => ::core::result::Result::Ok(__Field::__F13),
                            "rm_release" => ::core::result::Result::Ok(__Field::__F14),
                            "is_generated" => ::core::result::Result::Ok(__Field::__F15),
                            "other_meta_data" => ::core::result::Result::Ok(__Field::__F16),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_TEMPLATE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::persistence::archetype::p_template::PTemplate;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_TEMPLATE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<_> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s14: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s15: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s16: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("P_TEMPLATE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent_archetype_id"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("archetype_id"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_differential"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("definition"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("terminology"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rules"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("uid"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("original_language"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("description"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_controlled"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("annotations"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("translations"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("adl_version"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("build_uid"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F14 => {
                            if __s14.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_release"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F15 => {
                            if __s15.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_generated"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F16 => {
                            if __s16.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("other_meta_data"),
                                );
                            }
                            __s16 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::persistence::archetype::p_template::PTemplate {
                        parent_archetype_id: __s0.flatten(),
                        archetype_id: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("archetype_id"))?,
                        is_differential: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_differential"))?,
                        definition: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("definition"))?,
                        terminology: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("terminology"))?,
                        rules: __s5,
                        uid: __s6.flatten(),
                        original_language: __s7.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("original_language")
                        })?,
                        description: __s8.flatten(),
                        is_controlled: __s9.flatten(),
                        annotations: __s10.flatten(),
                        translations: __s11,
                        adl_version: __s12.flatten(),
                        build_uid: __s13
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("build_uid"))?,
                        rm_release: __s14
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("rm_release"))?,
                        is_generated: __s15
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_generated"))?,
                        other_meta_data: __s16
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("other_meta_data"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "P_TEMPLATE", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v2_4::bmm::rm_access::reference_model_access::ReferenceModelAccess
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self
            .schema_directories
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.all_schemas.is_some() {
            __n += 1;
        }
        if self.valid_models.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "REFERENCE_MODEL_ACCESS", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "REFERENCE_MODEL_ACCESS",
        )?;
        if let Some(__v) = &self.schema_directories
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "schema_directories", __v)?;
        }
        if let Some(__v) = &self.all_schemas {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "all_schemas", __v)?;
        }
        if let Some(__v) = &self.valid_models {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "valid_models", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm::rm_access::reference_model_access::ReferenceModelAccess
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["all_schemas", "schema_directories", "valid_models"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "schema_directories" => ::core::result::Result::Ok(__Field::__F0),
                            "all_schemas" => ::core::result::Result::Ok(__Field::__F1),
                            "valid_models" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "REFERENCE_MODEL_ACCESS",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::rm_access::reference_model_access::ReferenceModelAccess;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `REFERENCE_MODEL_ACCESS` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<_> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "REFERENCE_MODEL_ACCESS",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_directories"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("all_schemas"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("valid_models"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm::rm_access::reference_model_access::ReferenceModelAccess {
                        schema_directories: __s0,
                        all_schemas: __s1.flatten(),
                        valid_models: __s2.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "REFERENCE_MODEL_ACCESS",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::resource::resource_description::ResourceDescription {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.title.is_some() {
            __n += 1;
        }
        if self.original_namespace.is_some() {
            __n += 1;
        }
        if self.original_publisher.is_some() {
            __n += 1;
        }
        if self
            .other_contributors
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __n += 1;
        }
        if self.custodian_namespace.is_some() {
            __n += 1;
        }
        if self.custodian_organisation.is_some() {
            __n += 1;
        }
        if self.copyright.is_some() {
            __n += 1;
        }
        if self.licence.is_some() {
            __n += 1;
        }
        if self.ip_acknowledgements.is_some() {
            __n += 1;
        }
        if self.references.is_some() {
            __n += 1;
        }
        if self.resource_package_uri.is_some() {
            __n += 1;
        }
        if self.conversion_details.is_some() {
            __n += 1;
        }
        if self.details.is_some() {
            __n += 1;
        }
        if self.other_details.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "RESOURCE_DESCRIPTION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "RESOURCE_DESCRIPTION")?;
        if let Some(__v) = &self.title {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "title", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "original_author",
            &self.original_author,
        )?;
        if let Some(__v) = &self.original_namespace {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "original_namespace", __v)?;
        }
        if let Some(__v) = &self.original_publisher {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "original_publisher", __v)?;
        }
        if let Some(__v) = &self.other_contributors
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "other_contributors", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "lifecycle_state",
            &self.lifecycle_state,
        )?;
        if let Some(__v) = &self.custodian_namespace {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "custodian_namespace", __v)?;
        }
        if let Some(__v) = &self.custodian_organisation {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "custodian_organisation",
                __v,
            )?;
        }
        if let Some(__v) = &self.copyright {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "copyright", __v)?;
        }
        if let Some(__v) = &self.licence {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "licence", __v)?;
        }
        if let Some(__v) = &self.ip_acknowledgements {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "ip_acknowledgements", __v)?;
        }
        if let Some(__v) = &self.references {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "references", __v)?;
        }
        if let Some(__v) = &self.resource_package_uri {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "resource_package_uri", __v)?;
        }
        if let Some(__v) = &self.conversion_details {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "conversion_details", __v)?;
        }
        if let Some(__v) = &self.details {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "details", __v)?;
        }
        if let Some(__v) = &self.other_details {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "other_details", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::resource::resource_description::ResourceDescription
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "conversion_details",
            "copyright",
            "custodian_namespace",
            "custodian_organisation",
            "details",
            "ip_acknowledgements",
            "licence",
            "lifecycle_state",
            "original_author",
            "original_namespace",
            "original_publisher",
            "other_contributors",
            "other_details",
            "references",
            "resource_package_uri",
            "title",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
            __F14,
            __F15,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "title" => ::core::result::Result::Ok(__Field::__F0),
                            "original_author" => ::core::result::Result::Ok(__Field::__F1),
                            "original_namespace" => ::core::result::Result::Ok(__Field::__F2),
                            "original_publisher" => ::core::result::Result::Ok(__Field::__F3),
                            "other_contributors" => ::core::result::Result::Ok(__Field::__F4),
                            "lifecycle_state" => ::core::result::Result::Ok(__Field::__F5),
                            "custodian_namespace" => ::core::result::Result::Ok(__Field::__F6),
                            "custodian_organisation" => ::core::result::Result::Ok(__Field::__F7),
                            "copyright" => ::core::result::Result::Ok(__Field::__F8),
                            "licence" => ::core::result::Result::Ok(__Field::__F9),
                            "ip_acknowledgements" => ::core::result::Result::Ok(__Field::__F10),
                            "references" => ::core::result::Result::Ok(__Field::__F11),
                            "resource_package_uri" => ::core::result::Result::Ok(__Field::__F12),
                            "conversion_details" => ::core::result::Result::Ok(__Field::__F13),
                            "details" => ::core::result::Result::Ok(__Field::__F14),
                            "other_details" => ::core::result::Result::Ok(__Field::__F15),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "RESOURCE_DESCRIPTION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::resource::resource_description::ResourceDescription;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `RESOURCE_DESCRIPTION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<_> = None;
                let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s14: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s15: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("RESOURCE_DESCRIPTION"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("title"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("original_author"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("original_namespace"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("original_publisher"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("other_contributors"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("lifecycle_state"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("custodian_namespace"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("custodian_organisation"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("copyright"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("licence"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("ip_acknowledgements"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("references"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("resource_package_uri"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("conversion_details"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F14 => {
                            if __s14.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("details"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F15 => {
                            if __s15.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("other_details"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::resource::resource_description::ResourceDescription {
                        title: __s0.flatten(),
                        original_author: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("original_author"))?,
                        original_namespace: __s2.flatten(),
                        original_publisher: __s3.flatten(),
                        other_contributors: __s4,
                        lifecycle_state: __s5
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("lifecycle_state"))?,
                        custodian_namespace: __s6.flatten(),
                        custodian_organisation: __s7.flatten(),
                        copyright: __s8.flatten(),
                        licence: __s9.flatten(),
                        ip_acknowledgements: __s10.flatten(),
                        references: __s11.flatten(),
                        resource_package_uri: __s12.flatten(),
                        conversion_details: __s13.flatten(),
                        details: __s14.flatten(),
                        other_details: __s15.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "RESOURCE_DESCRIPTION",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::rm_overlay::rm_attribute_visibility::RmAttributeVisibility
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.visibility.is_some() {
            __n += 1;
        }
        if self.alias.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "RM_ATTRIBUTE_VISIBILITY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "RM_ATTRIBUTE_VISIBILITY",
        )?;
        if let Some(__v) = &self.visibility {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "visibility", __v)?;
        }
        if let Some(__v) = &self.alias {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "alias", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::rm_overlay::rm_attribute_visibility::RmAttributeVisibility
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["alias", "visibility"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "visibility" => ::core::result::Result::Ok(__Field::__F0),
                            "alias" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "RM_ATTRIBUTE_VISIBILITY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v2_4::aom2::rm_overlay::rm_attribute_visibility::RmAttributeVisibility;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `RM_ATTRIBUTE_VISIBILITY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType(
                                    "RM_ATTRIBUTE_VISIBILITY",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("visibility"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("alias"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::rm_overlay::rm_attribute_visibility::RmAttributeVisibility {
                        visibility: __s0.flatten(),
                        alias: __s1.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "RM_ATTRIBUTE_VISIBILITY",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::rm_overlay::rm_overlay::RmOverlay {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.rm_visibility.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "RM_OVERLAY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "RM_OVERLAY")?;
        if let Some(__v) = &self.rm_visibility {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_visibility", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::aom2::rm_overlay::rm_overlay::RmOverlay {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["rm_visibility"];
        enum __Field {
            __Type,
            __F0,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "rm_visibility" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "RM_OVERLAY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::rm_overlay::rm_overlay::RmOverlay;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `RM_OVERLAY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("RM_OVERLAY"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_visibility"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::aom2::rm_overlay::rm_overlay::RmOverlay {
                    rm_visibility: __s0.flatten(),
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "RM_OVERLAY", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::rm_access::schema_descriptor::SchemaDescriptorData {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.p_schema.is_some() {
            __n += 1;
        }
        if self.schema.is_some() {
            __n += 1;
        }
        if self.includes.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "SCHEMA_DESCRIPTOR", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "SCHEMA_DESCRIPTOR")?;
        if let Some(__v) = &self.p_schema {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "p_schema", __v)?;
        }
        if let Some(__v) = &self.schema {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "schema", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "schema_id", &self.schema_id)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "meta_data", &self.meta_data)?;
        if let Some(__v) = &self.includes
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "includes", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm::rm_access::schema_descriptor::SchemaDescriptorData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["includes", "meta_data", "p_schema", "schema", "schema_id"];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "p_schema" => ::core::result::Result::Ok(__Field::__F0),
                            "schema" => ::core::result::Result::Ok(__Field::__F1),
                            "schema_id" => ::core::result::Result::Ok(__Field::__F2),
                            "meta_data" => ::core::result::Result::Ok(__Field::__F3),
                            "includes" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "SCHEMA_DESCRIPTOR",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::rm_access::schema_descriptor::SchemaDescriptorData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `SCHEMA_DESCRIPTOR` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("SCHEMA_DESCRIPTOR"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("p_schema"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("schema_id"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("meta_data"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("includes"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::bmm::rm_access::schema_descriptor::SchemaDescriptorData {
                        p_schema: __s0.flatten(),
                        schema: __s1.flatten(),
                        schema_id: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("schema_id"))?,
                        meta_data: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("meta_data"))?,
                        includes: __s4,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "SCHEMA_DESCRIPTOR",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::bmm::rm_access::schema_descriptor::SchemaDescriptor {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v2_4::bmm::rm_access::schema_descriptor::SchemaDescriptor::PBmmSchemaDescriptor(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v2_4::bmm::rm_access::schema_descriptor::SchemaDescriptor::SchemaDescriptor(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::bmm::rm_access::schema_descriptor::SchemaDescriptor
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["P_BMM_SCHEMA_DESCRIPTOR", "SCHEMA_DESCRIPTOR"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::bmm::rm_access::schema_descriptor::SchemaDescriptor;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `SCHEMA_DESCRIPTOR` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"P_BMM_SCHEMA_DESCRIPTOR" => ::core::result::Result::Ok(crate::v2_4::bmm::rm_access::schema_descriptor::SchemaDescriptor::PBmmSchemaDescriptor(::serde::Deserialize::deserialize(__rest)?)),
"SCHEMA_DESCRIPTOR" => ::core::result::Result::Ok(crate::v2_4::bmm::rm_access::schema_descriptor::SchemaDescriptor::SchemaDescriptor(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("SCHEMA_DESCRIPTOR", __other, "P_BMM_SCHEMA_DESCRIPTOR, SCHEMA_DESCRIPTOR")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "SCHEMA_DESCRIPTOR",
                            &__other,
                            "P_BMM_SCHEMA_DESCRIPTOR, SCHEMA_DESCRIPTOR",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v2_4::bmm::rm_access::schema_descriptor::SchemaDescriptor::SchemaDescriptor(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::constraint_model::sibling_order::SiblingOrder {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "SIBLING_ORDER", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "SIBLING_ORDER")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_before", &self.is_before)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "sibling_node_id",
            &self.sibling_node_id,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::constraint_model::sibling_order::SiblingOrder
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["is_before", "sibling_node_id"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "is_before" => ::core::result::Result::Ok(__Field::__F0),
                            "sibling_node_id" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "SIBLING_ORDER",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::constraint_model::sibling_order::SiblingOrder;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `SIBLING_ORDER` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("SIBLING_ORDER"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_before"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("sibling_node_id"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::constraint_model::sibling_order::SiblingOrder {
                        is_before: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_before"))?,
                        sibling_node_id: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("sibling_node_id"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "SIBLING_ORDER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::beom::core::statement::Statement {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::beom::core::statement::Statement::Assertion(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::statement::Statement::Assignment(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v2_4::beom::core::statement::Statement::VariableDeclaration(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::beom::core::statement::Statement {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["ASSERTION", "ASSIGNMENT", "VARIABLE_DECLARATION"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::beom::core::statement::Statement;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `STATEMENT` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
                            "ASSERTION" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::statement::Statement::Assertion(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "ASSIGNMENT" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::statement::Statement::Assignment(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "VARIABLE_DECLARATION" => ::core::result::Result::Ok(
                                crate::v2_4::beom::core::statement::Statement::VariableDeclaration(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            __other => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unexpected_type(
                                    "STATEMENT",
                                    __other,
                                    "ASSERTION, ASSIGNMENT, VARIABLE_DECLARATION",
                                ),
                            ),
                        }
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "STATEMENT",
                            &__other,
                            "ASSERTION, ASSIGNMENT, VARIABLE_DECLARATION",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "STATEMENT",
                            "ASSERTION, ASSIGNMENT, VARIABLE_DECLARATION",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::beom::core::statement_set::StatementSet {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.statement.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.name.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "STATEMENT_SET", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "STATEMENT_SET")?;
        if let Some(__v) = &self.statement
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "statement", __v)?;
        }
        if let Some(__v) = &self.name {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::beom::core::statement_set::StatementSet {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["name", "statement"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "statement" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "STATEMENT_SET",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::beom::core::statement_set::StatementSet;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `STATEMENT_SET` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<_> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("STATEMENT_SET"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("statement"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("name"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::beom::core::statement_set::StatementSet {
                    statement: __s0,
                    name: __s1.flatten(),
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "STATEMENT_SET",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::archetype::template::Template {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 10usize;
        if self.parent_archetype_id.is_some() {
            __n += 1;
        }
        if self.rules.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.rm_overlay.is_some() {
            __n += 1;
        }
        if self.uid.is_some() {
            __n += 1;
        }
        if self.description.is_some() {
            __n += 1;
        }
        if self.is_controlled.is_some() {
            __n += 1;
        }
        if self.annotations.is_some() {
            __n += 1;
        }
        if self.translations.is_some() {
            __n += 1;
        }
        if self.adl_version.is_some() {
            __n += 1;
        }
        if self.overlays.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "TEMPLATE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TEMPLATE")?;
        if let Some(__v) = &self.parent_archetype_id {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent_archetype_id", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "archetype_id",
            &self.archetype_id,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_differential",
            &self.is_differential,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", &self.definition)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "terminology",
            &self.terminology,
        )?;
        if let Some(__v) = &self.rules
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rules", __v)?;
        }
        if let Some(__v) = &self.rm_overlay {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_overlay", __v)?;
        }
        if let Some(__v) = &self.uid {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "uid", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "original_language",
            &self.original_language,
        )?;
        if let Some(__v) = &self.description {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "description", __v)?;
        }
        if let Some(__v) = &self.is_controlled {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_controlled", __v)?;
        }
        if let Some(__v) = &self.annotations {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "annotations", __v)?;
        }
        if let Some(__v) = &self.translations {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "translations", __v)?;
        }
        if let Some(__v) = &self.adl_version {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "adl_version", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "build_uid", &self.build_uid)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_release", &self.rm_release)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_generated",
            &self.is_generated,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "other_meta_data",
            &self.other_meta_data,
        )?;
        if let Some(__v) = &self.overlays
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "overlays", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::aom2::archetype::template::Template {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "adl_version",
            "annotations",
            "archetype_id",
            "build_uid",
            "definition",
            "description",
            "is_controlled",
            "is_differential",
            "is_generated",
            "original_language",
            "other_meta_data",
            "overlays",
            "parent_archetype_id",
            "rm_overlay",
            "rm_release",
            "rules",
            "terminology",
            "translations",
            "uid",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
            __F7,
            __F8,
            __F9,
            __F10,
            __F11,
            __F12,
            __F13,
            __F14,
            __F15,
            __F16,
            __F17,
            __F18,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent_archetype_id" => ::core::result::Result::Ok(__Field::__F0),
                            "archetype_id" => ::core::result::Result::Ok(__Field::__F1),
                            "is_differential" => ::core::result::Result::Ok(__Field::__F2),
                            "definition" => ::core::result::Result::Ok(__Field::__F3),
                            "terminology" => ::core::result::Result::Ok(__Field::__F4),
                            "rules" => ::core::result::Result::Ok(__Field::__F5),
                            "rm_overlay" => ::core::result::Result::Ok(__Field::__F6),
                            "uid" => ::core::result::Result::Ok(__Field::__F7),
                            "original_language" => ::core::result::Result::Ok(__Field::__F8),
                            "description" => ::core::result::Result::Ok(__Field::__F9),
                            "is_controlled" => ::core::result::Result::Ok(__Field::__F10),
                            "annotations" => ::core::result::Result::Ok(__Field::__F11),
                            "translations" => ::core::result::Result::Ok(__Field::__F12),
                            "adl_version" => ::core::result::Result::Ok(__Field::__F13),
                            "build_uid" => ::core::result::Result::Ok(__Field::__F14),
                            "rm_release" => ::core::result::Result::Ok(__Field::__F15),
                            "is_generated" => ::core::result::Result::Ok(__Field::__F16),
                            "other_meta_data" => ::core::result::Result::Ok(__Field::__F17),
                            "overlays" => ::core::result::Result::Ok(__Field::__F18),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v, "TEMPLATE", __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::archetype::template::Template;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TEMPLATE` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s7: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s8: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s9: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s10: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s11: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s12: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s13: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s14: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s15: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s16: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s17: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s18: ::core::option::Option<_> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("TEMPLATE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent_archetype_id"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("archetype_id"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_differential"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("definition"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("terminology"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rules"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_overlay"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F7 => {
                            if __s7.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("uid"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F8 => {
                            if __s8.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("original_language"),
                                );
                            }
                            __s8 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F9 => {
                            if __s9.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("description"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F10 => {
                            if __s10.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_controlled"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F11 => {
                            if __s11.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("annotations"),
                                );
                            }
                            __s11 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("translations"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F13 => {
                            if __s13.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("adl_version"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F14 => {
                            if __s14.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("build_uid"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F15 => {
                            if __s15.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_release"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F16 => {
                            if __s16.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_generated"),
                                );
                            }
                            __s16 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F17 => {
                            if __s17.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("other_meta_data"),
                                );
                            }
                            __s17 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F18 => {
                            if __s18.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("overlays"),
                                );
                            }
                            __s18 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::aom2::archetype::template::Template {
                    parent_archetype_id: __s0.flatten(),
                    archetype_id: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("archetype_id"))?,
                    is_differential: __s2
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("is_differential"))?,
                    definition: __s3
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("definition"))?,
                    terminology: __s4
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("terminology"))?,
                    rules: __s5,
                    rm_overlay: __s6.flatten(),
                    uid: __s7.flatten(),
                    original_language: __s8
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("original_language"))?,
                    description: __s9.flatten(),
                    is_controlled: __s10.flatten(),
                    annotations: __s11.flatten(),
                    translations: __s12.flatten(),
                    adl_version: __s13.flatten(),
                    build_uid: __s14
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("build_uid"))?,
                    rm_release: __s15
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("rm_release"))?,
                    is_generated: __s16
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("is_generated"))?,
                    other_meta_data: __s17
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("other_meta_data"))?,
                    overlays: __s18,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "TEMPLATE", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::archetype::template_overlay::TemplateOverlay {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.parent_archetype_id.is_some() {
            __n += 1;
        }
        if self.rules.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.rm_overlay.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "TEMPLATE_OVERLAY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TEMPLATE_OVERLAY")?;
        if let Some(__v) = &self.parent_archetype_id {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "parent_archetype_id", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "archetype_id",
            &self.archetype_id,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_differential",
            &self.is_differential,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", &self.definition)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "terminology",
            &self.terminology,
        )?;
        if let Some(__v) = &self.rules
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rules", __v)?;
        }
        if let Some(__v) = &self.rm_overlay {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "rm_overlay", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::archetype::template_overlay::TemplateOverlay
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "archetype_id",
            "definition",
            "is_differential",
            "parent_archetype_id",
            "rm_overlay",
            "rules",
            "terminology",
        ];
        enum __Field {
            __Type,
            __F0,
            __F1,
            __F2,
            __F3,
            __F4,
            __F5,
            __F6,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "parent_archetype_id" => ::core::result::Result::Ok(__Field::__F0),
                            "archetype_id" => ::core::result::Result::Ok(__Field::__F1),
                            "is_differential" => ::core::result::Result::Ok(__Field::__F2),
                            "definition" => ::core::result::Result::Ok(__Field::__F3),
                            "terminology" => ::core::result::Result::Ok(__Field::__F4),
                            "rules" => ::core::result::Result::Ok(__Field::__F5),
                            "rm_overlay" => ::core::result::Result::Ok(__Field::__F6),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TEMPLATE_OVERLAY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::archetype::template_overlay::TemplateOverlay;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TEMPLATE_OVERLAY` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s5: ::core::option::Option<_> = None;
                let mut __s6: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("TEMPLATE_OVERLAY"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("parent_archetype_id"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("archetype_id"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("is_differential"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F3 => {
                            if __s3.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("definition"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F4 => {
                            if __s4.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("terminology"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F5 => {
                            if __s5.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rules"),
                                );
                            }
                            __s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F6 => {
                            if __s6.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("rm_overlay"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::archetype::template_overlay::TemplateOverlay {
                        parent_archetype_id: __s0.flatten(),
                        archetype_id: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("archetype_id"))?,
                        is_differential: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_differential"))?,
                        definition: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("definition"))?,
                        terminology: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("terminology"))?,
                        rules: __s5,
                        rm_overlay: __s6.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TEMPLATE_OVERLAY",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v2_4::aom2::terminology::terminology_relation::TerminologyRelation
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v2_4::aom2::terminology::terminology_relation::TerminologyRelation::ValueSet(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::terminology::terminology_relation::TerminologyRelation
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["VALUE_SET"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::terminology::terminology_relation::TerminologyRelation;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TERMINOLOGY_RELATION` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
"VALUE_SET" => ::core::result::Result::Ok(crate::v2_4::aom2::terminology::terminology_relation::TerminologyRelation::ValueSet(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("TERMINOLOGY_RELATION", __other, "VALUE_SET")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "TERMINOLOGY_RELATION",
                            &__other,
                            "VALUE_SET",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "TERMINOLOGY_RELATION",
                            "VALUE_SET",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::terminology::value_set::ValueSet {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "VALUE_SET", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "VALUE_SET")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "id", &self.id)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "members", &self.members)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v2_4::aom2::terminology::value_set::ValueSet {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["id", "members"];
        enum __Field {
            __Type,
            __F0,
            __F1,
        }
        impl<'de> ::serde::Deserialize<'de> for __Field {
            fn deserialize<__D: ::serde::Deserializer<'de>>(
                __deserializer: __D,
            ) -> ::core::result::Result<Self, __D::Error> {
                struct __KeyVisitor;
                impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        __f.write_str("an object member name")
                    }
                    fn visit_str<__E: ::serde::de::Error>(
                        self,
                        __v: &str,
                    ) -> ::core::result::Result<__Field, __E> {
                        match __v {
                            "_type" => ::core::result::Result::Ok(__Field::__Type),
                            "id" => ::core::result::Result::Ok(__Field::__F0),
                            "members" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "VALUE_SET",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v2_4::aom2::terminology::value_set::ValueSet;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `VALUE_SET` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let mut __seen_type = false;
                let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
                let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
                while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                    match __key {
                        __Field::__Type => {
                            if __seen_type {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("_type"),
                                );
                            }
                            __seen_type = true;
                            ::serde::de::MapAccess::next_value_seed(
                                &mut __map,
                                ::openehr_base::serde_support::ExpectedType("VALUE_SET"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("id"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                        __Field::__F1 => {
                            if __s1.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("members"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v2_4::aom2::terminology::value_set::ValueSet {
                    id: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("id"))?,
                    members: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("members"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "VALUE_SET", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v2_4::aom2::rm_overlay::visibility_type::VisibilityType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serializer::serialize_str(__serializer, self.as_str())
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v2_4::aom2::rm_overlay::visibility_type::VisibilityType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        struct __V;
        impl<'de> ::serde::de::Visitor<'de> for __V {
            type Value = crate::v2_4::aom2::rm_overlay::visibility_type::VisibilityType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("a `VisibilityType` token")
            }
            fn visit_str<__E: ::serde::de::Error>(
                self,
                __v: &str,
            ) -> ::core::result::Result<Self::Value, __E> {
                ::core::result::Result::Ok(
                    crate::v2_4::aom2::rm_overlay::visibility_type::VisibilityType::from_wire(__v),
                )
            }
        }
        ::serde::Deserializer::deserialize_str(__deserializer, __V)
    }
}