openehr-lang 0.0.128

// @generated by openehr-codegen (emit-json) — DO NOT EDIT.
// SPDX-FileCopyrightText: Cadasto 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_0::bmm::statement::bmm_action_table::BmmActionTable {
    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_ACTION_TABLE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_ACTION_TABLE")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "items", &self.items)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::statement::bmm_action_table::BmmActionTable
{
    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_ACTION_TABLE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::statement::bmm_action_table::BmmActionTable;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_ACTION_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;
                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_ACTION_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)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::statement::bmm_action_table::BmmActionTable {
                        items: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("items"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_ACTION_TABLE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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, "type", &self.r#type)?;
        ::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::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::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),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "value_literal" => ::core::result::Result::Ok(__Field::__F1),
                            "value" => ::core::result::Result::Ok(__Field::__F2),
                            "syntax" => ::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::v1_0::bmm::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("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_literal"),
                                );
                            }
                            __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("value"),
                                );
                            }
                            __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("syntax"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::core::literal_value::bmm_boolean_value::BmmBooleanValue {
                        r#type: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        value_literal: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("value_literal"))?,
                        value: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("value"))?,
                        syntax: __s3.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_BOOLEAN_VALUE",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::core::entity::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::v1_0::bmm::core::entity::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::v1_0::bmm::core::entity::bmm_class::BmmClass::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::bmm_class::BmmClass::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::bmm_class::BmmClass::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_CLASS" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::bmm_class::BmmClass::BmmGenericClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_CLASS" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::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::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity::BmmConstant(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity::BmmContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity::BmmFunction(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity::BmmLocal(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity::BmmParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity::BmmProcedure(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity::BmmResult(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity::BmmUnitaryProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity
{
    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_UNITARY_PROPERTY",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_CLASS_ENTITY` 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::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity::BmmConstant(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_FUNCTION" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity::BmmFunction(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_LOCAL" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity::BmmLocal(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PARAMETER" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity::BmmParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity::BmmProcedure(::serde::Deserialize::deserialize(__rest)?)),
"BMM_RESULT" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity::BmmResult(::serde::Deserialize::deserialize(__rest)?)),
"BMM_UNITARY_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_class_entity::BmmClassEntity::BmmUnitaryProperty(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_CLASS_ENTITY", __other, "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_PARAMETER, BMM_PROCEDURE, BMM_RESULT, BMM_UNITARY_PROPERTY")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_CLASS_ENTITY",
                            &__other,
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_PARAMETER, BMM_PROCEDURE, BMM_RESULT, BMM_UNITARY_PROPERTY",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_CLASS_ENTITY",
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_PARAMETER, BMM_PROCEDURE, BMM_RESULT, BMM_UNITARY_PROPERTY",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::core::feature::bmm_class_feature::BmmClassFeature {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_0::bmm::core::feature::bmm_class_feature::BmmClassFeature::BmmConstant(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_class_feature::BmmClassFeature::BmmContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_class_feature::BmmClassFeature::BmmFunction(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_class_feature::BmmClassFeature::BmmProcedure(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_class_feature::BmmClassFeature::BmmUnitaryProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::feature::bmm_class_feature::BmmClassFeature
{
    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_UNITARY_PROPERTY",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::core::feature::bmm_class_feature::BmmClassFeature;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_CLASS_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::v1_0::bmm::core::feature::bmm_class_feature::BmmClassFeature::BmmConstant(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_class_feature::BmmClassFeature::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_FUNCTION" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_class_feature::BmmClassFeature::BmmFunction(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_class_feature::BmmClassFeature::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_class_feature::BmmClassFeature::BmmProcedure(::serde::Deserialize::deserialize(__rest)?)),
"BMM_UNITARY_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_class_feature::BmmClassFeature::BmmUnitaryProperty(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_CLASS_FEATURE", __other, "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_PROCEDURE, BMM_UNITARY_PROPERTY")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_CLASS_FEATURE",
                            &__other,
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_PROCEDURE, BMM_UNITARY_PROPERTY",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_CLASS_FEATURE",
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_PROCEDURE, BMM_UNITARY_PROPERTY",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::statement::bmm_conditional_action::BmmConditionalAction
{
    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_CONDITIONAL_ACTION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "BMM_CONDITIONAL_ACTION",
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "condition", &self.condition)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "statement", &self.statement)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::statement::bmm_conditional_action::BmmConditionalAction
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["condition", "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),
                            "condition" => ::core::result::Result::Ok(__Field::__F0),
                            "statement" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_CONDITIONAL_ACTION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::statement::bmm_conditional_action::BmmConditionalAction;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_CONDITIONAL_ACTION` 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_CONDITIONAL_ACTION",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("condition"),
                                );
                            }
                            __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("statement"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::statement::bmm_conditional_action::BmmConditionalAction {
                        condition: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("condition"))?,
                        statement: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("statement"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_CONDITIONAL_ACTION",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::core::feature::bmm_constant::BmmConstant {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 6usize;
        if self.is_nullable.is_some() {
            __n += 1;
        }
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_synthesised_generic.is_some() {
            __n += 1;
        }
        if self.visibility.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, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        ::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)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "scope", &self.scope)?;
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __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.visibility {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "visibility", __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::v1_0::bmm::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",
            "scope",
            "type",
            "visibility",
        ];
        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),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F1),
                            "name" => ::core::result::Result::Ok(__Field::__F2),
                            "documentation" => ::core::result::Result::Ok(__Field::__F3),
                            "scope" => ::core::result::Result::Ok(__Field::__F4),
                            "extensions" => ::core::result::Result::Ok(__Field::__F5),
                            "is_synthesised_generic" => ::core::result::Result::Ok(__Field::__F6),
                            "visibility" => ::core::result::Result::Ok(__Field::__F7),
                            "feature_extensions" => ::core::result::Result::Ok(__Field::__F8),
                            "group" => ::core::result::Result::Ok(__Field::__F9),
                            "generator" => ::core::result::Result::Ok(__Field::__F10),
                            _ => ::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::v1_0::bmm::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<::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;
                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("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("is_nullable"),
                                );
                            }
                            __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("documentation"),
                                );
                            }
                            __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("scope"),
                                );
                            }
                            __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("extensions"),
                                );
                            }
                            __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_synthesised_generic"),
                                );
                            }
                            __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("visibility"),
                                );
                            }
                            __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("feature_extensions"),
                                );
                            }
                            __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("group"),
                                );
                            }
                            __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("generator"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::core::feature::bmm_constant::BmmConstant {
                        r#type: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        is_nullable: __s1.flatten(),
                        name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s3.flatten(),
                        scope: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("scope"))?,
                        extensions: __s5.flatten(),
                        is_synthesised_generic: __s6.flatten(),
                        visibility: __s7.flatten(),
                        feature_extensions: __s8,
                        group: __s9
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("group"))?,
                        generator: __s10
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("generator"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_CONSTANT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::core::feature::bmm_container_property::BmmContainerPropertyData
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.is_nullable.is_some() {
            __n += 1;
        }
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_synthesised_generic.is_some() {
            __n += 1;
        }
        if self.visibility.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, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        ::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)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "scope", &self.scope)?;
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __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.visibility {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "visibility", __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::v1_0::bmm::core::feature::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",
            "scope",
            "type",
            "visibility",
        ];
        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),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F1),
                            "name" => ::core::result::Result::Ok(__Field::__F2),
                            "documentation" => ::core::result::Result::Ok(__Field::__F3),
                            "scope" => ::core::result::Result::Ok(__Field::__F4),
                            "extensions" => ::core::result::Result::Ok(__Field::__F5),
                            "is_synthesised_generic" => ::core::result::Result::Ok(__Field::__F6),
                            "visibility" => ::core::result::Result::Ok(__Field::__F7),
                            "feature_extensions" => ::core::result::Result::Ok(__Field::__F8),
                            "group" => ::core::result::Result::Ok(__Field::__F9),
                            "is_im_runtime" => ::core::result::Result::Ok(__Field::__F10),
                            "is_im_infrastructure" => ::core::result::Result::Ok(__Field::__F11),
                            "is_composition" => ::core::result::Result::Ok(__Field::__F12),
                            "cardinality" => ::core::result::Result::Ok(__Field::__F13),
                            _ => ::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::v1_0::bmm::core::feature::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<::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<::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_CONTAINER_PROPERTY",
                                ),
                            )?;
                        }
                        __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("is_nullable"),
                                );
                            }
                            __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("documentation"),
                                );
                            }
                            __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("scope"),
                                );
                            }
                            __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("extensions"),
                                );
                            }
                            __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_synthesised_generic"),
                                );
                            }
                            __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("visibility"),
                                );
                            }
                            __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("feature_extensions"),
                                );
                            }
                            __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("group"),
                                );
                            }
                            __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_im_runtime"),
                                );
                            }
                            __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("is_im_infrastructure"),
                                );
                            }
                            __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("is_composition"),
                                );
                            }
                            __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("cardinality"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_container_property::BmmContainerPropertyData {
r#type: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
is_nullable: __s1.flatten(),
name: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
documentation: __s3.flatten(),
scope: __s4.flatten().ok_or_else(|| ::serde::de::Error::missing_field("scope"))?,
extensions: __s5.flatten(),
is_synthesised_generic: __s6.flatten(),
visibility: __s7.flatten(),
feature_extensions: __s8,
group: __s9.flatten().ok_or_else(|| ::serde::de::Error::missing_field("group"))?,
is_im_runtime: __s10.flatten(),
is_im_infrastructure: __s11.flatten(),
is_composition: __s12.flatten(),
cardinality: __s13.flatten(),
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_CONTAINER_PROPERTY",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::feature::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::v1_0::bmm::core::feature::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::v1_0::bmm::core::feature::bmm_container_property::BmmContainerProperty::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::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::v1_0::bmm::core::feature::bmm_container_property::BmmContainerProperty::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::entity::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::v1_0::bmm::core::entity::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::v1_0::bmm::core::entity::bmm_container_type::BmmContainerType::BmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::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::v1_0::bmm::core::entity::bmm_container_type::BmmContainerType::BmmContainerType(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::core::literal_value::bmm_container_value::BmmContainerValueData
{
    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_CONTAINER_VALUE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_CONTAINER_VALUE")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        ::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::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::literal_value::bmm_container_value::BmmContainerValueData
{
    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),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "value_literal" => ::core::result::Result::Ok(__Field::__F1),
                            "value" => ::core::result::Result::Ok(__Field::__F2),
                            "syntax" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_CONTAINER_VALUE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_0::bmm::core::literal_value::bmm_container_value::BmmContainerValueData;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_CONTAINER_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_CONTAINER_VALUE"),
                            )?;
                        }
                        __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("value_literal"),
                                );
                            }
                            __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("value"),
                                );
                            }
                            __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("syntax"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_0::bmm::core::literal_value::bmm_container_value::BmmContainerValueData {
r#type: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
value_literal: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("value_literal"))?,
value: __s2.flatten(),
syntax: __s3.flatten(),
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_CONTAINER_VALUE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::core::literal_value::bmm_container_value::BmmContainerValue
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_0::bmm::core::literal_value::bmm_container_value::BmmContainerValue::BmmIndexedContainerValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::literal_value::bmm_container_value::BmmContainerValue::BmmContainerValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::literal_value::bmm_container_value::BmmContainerValue
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_CONTAINER_VALUE", "BMM_INDEXED_CONTAINER_VALUE"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_0::bmm::core::literal_value::bmm_container_value::BmmContainerValue;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_CONTAINER_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_CONTAINER_VALUE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::literal_value::bmm_container_value::BmmContainerValue::BmmContainerValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_VALUE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::literal_value::bmm_container_value::BmmContainerValue::BmmIndexedContainerValue(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_CONTAINER_VALUE", __other, "BMM_CONTAINER_VALUE, BMM_INDEXED_CONTAINER_VALUE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_CONTAINER_VALUE",
                            &__other,
                            "BMM_CONTAINER_VALUE, BMM_INDEXED_CONTAINER_VALUE",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v1_0::bmm::core::literal_value::bmm_container_value::BmmContainerValue::BmmContainerValue(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::core::bmm_declaration::BmmDeclaration {
    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_INDEXED_CONTAINER_PROPERTY",
            "BMM_LOCAL",
            "BMM_MODEL",
            "BMM_PACKAGE",
            "BMM_PARAMETER",
            "BMM_PROCEDURE",
            "BMM_RESULT",
            "BMM_SIMPLE_CLASS",
            "BMM_UNITARY_PROPERTY",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::core::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 (__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::v1_0::bmm::core::bmm_declaration::BmmDeclaration::BmmConstant(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::bmm_declaration::BmmDeclaration::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION" => ::core::result::Result::Ok(crate::v1_0::bmm::core::bmm_declaration::BmmDeclaration::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_0::bmm::core::bmm_declaration::BmmDeclaration::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_0::bmm::core::bmm_declaration::BmmDeclaration::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_FUNCTION" => ::core::result::Result::Ok(crate::v1_0::bmm::core::bmm_declaration::BmmDeclaration::BmmFunction(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_CLASS" => ::core::result::Result::Ok(crate::v1_0::bmm::core::bmm_declaration::BmmDeclaration::BmmGenericClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::bmm_declaration::BmmDeclaration::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_LOCAL" => ::core::result::Result::Ok(crate::v1_0::bmm::core::bmm_declaration::BmmDeclaration::BmmLocal(::serde::Deserialize::deserialize(__rest)?)),
"BMM_MODEL" => ::core::result::Result::Ok(crate::v1_0::bmm::core::bmm_declaration::BmmDeclaration::BmmModel(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PACKAGE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::bmm_declaration::BmmDeclaration::BmmPackage(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PARAMETER" => ::core::result::Result::Ok(crate::v1_0::bmm::core::bmm_declaration::BmmDeclaration::BmmParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::bmm_declaration::BmmDeclaration::BmmProcedure(::serde::Deserialize::deserialize(__rest)?)),
"BMM_RESULT" => ::core::result::Result::Ok(crate::v1_0::bmm::core::bmm_declaration::BmmDeclaration::BmmResult(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_CLASS" => ::core::result::Result::Ok(crate::v1_0::bmm::core::bmm_declaration::BmmDeclaration::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_UNITARY_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::bmm_declaration::BmmDeclaration::BmmUnitaryProperty(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_DECLARATION", __other, "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_FUNCTION, BMM_GENERIC_CLASS, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_MODEL, BMM_PACKAGE, BMM_PARAMETER, BMM_PROCEDURE, BMM_RESULT, BMM_SIMPLE_CLASS, BMM_UNITARY_PROPERTY")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_DECLARATION",
                            &__other,
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_FUNCTION, BMM_GENERIC_CLASS, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_MODEL, BMM_PACKAGE, BMM_PARAMETER, BMM_PROCEDURE, BMM_RESULT, BMM_SIMPLE_CLASS, BMM_UNITARY_PROPERTY",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_DECLARATION",
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_FUNCTION, BMM_GENERIC_CLASS, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_MODEL, BMM_PACKAGE, BMM_PARAMETER, BMM_PROCEDURE, BMM_RESULT, BMM_SIMPLE_CLASS, BMM_UNITARY_PROPERTY",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::bmm_definitions::BmmDefinitions {
    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::v1_0::bmm::bmm_definitions::BmmDefinitions {
    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::v1_0::bmm::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 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::v1_0::bmm::bmm_definitions::BmmDefinitions {})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_DEFINITIONS",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::entity::bmm_effective_type::BmmEffectiveType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_GENERIC_TYPE",
            "BMM_SIGNATURE",
            "BMM_SIMPLE_TYPE",
            "BMM_TUPLE_TYPE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::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_GENERIC_TYPE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::bmm_effective_type::BmmEffectiveType::BmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIGNATURE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::bmm_effective_type::BmmEffectiveType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::bmm_effective_type::BmmEffectiveType::BmmSimpleType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_TUPLE_TYPE" => ::core::result::Result::Ok(crate::v1_0::bmm::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_GENERIC_TYPE, BMM_SIGNATURE, BMM_SIMPLE_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_GENERIC_TYPE, BMM_SIGNATURE, BMM_SIMPLE_TYPE, BMM_TUPLE_TYPE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_EFFECTIVE_TYPE",
                            "BMM_GENERIC_TYPE, BMM_SIGNATURE, BMM_SIMPLE_TYPE, BMM_TUPLE_TYPE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::core::entity::bmm_entity_metatype::BmmEntityMetatype {
    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_0::bmm::core::entity::bmm_entity_metatype::BmmEntityMetatype
{
    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_0::bmm::core::entity::bmm_entity_metatype::BmmEntityMetatype;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("a `BmmEntityMetatype` token")
            }
            fn visit_str<__E: ::serde::de::Error>(
                self,
                __v: &str,
            ) -> ::core::result::Result<Self::Value, __E> {
                ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::bmm_entity_metatype::BmmEntityMetatype::from_wire(__v))
            }
        }
        ::serde::Deserializer::deserialize_str(__deserializer, __V)
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::core::entity::range_constrained::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.ancestors.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __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.constants.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.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.converters.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self
            .feature_groups
            .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;
        }
        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.ancestors
            && !__v.is_empty()
        {
            ::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.constants {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constants", __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
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "creators", __v)?;
        }
        if let Some(__v) = &self.converters
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "converters", __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.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::v1_0::bmm::core::entity::range_constrained::bmm_enumeration::BmmEnumerationData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "ancestors",
            "constants",
            "converters",
            "creators",
            "documentation",
            "extensions",
            "feature_groups",
            "functions",
            "immediate_descendants",
            "invariants",
            "is_abstract",
            "is_override",
            "is_primitive",
            "item_names",
            "item_values",
            "name",
            "package",
            "procedures",
            "properties",
            "source_schema_id",
        ];
        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),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F3),
                            "package" => ::core::result::Result::Ok(__Field::__F4),
                            "properties" => ::core::result::Result::Ok(__Field::__F5),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F6),
                            "immediate_descendants" => ::core::result::Result::Ok(__Field::__F7),
                            "is_override" => ::core::result::Result::Ok(__Field::__F8),
                            "constants" => ::core::result::Result::Ok(__Field::__F9),
                            "functions" => ::core::result::Result::Ok(__Field::__F10),
                            "procedures" => ::core::result::Result::Ok(__Field::__F11),
                            "is_primitive" => ::core::result::Result::Ok(__Field::__F12),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F13),
                            "invariants" => ::core::result::Result::Ok(__Field::__F14),
                            "creators" => ::core::result::Result::Ok(__Field::__F15),
                            "converters" => ::core::result::Result::Ok(__Field::__F16),
                            "feature_groups" => ::core::result::Result::Ok(__Field::__F17),
                            "item_names" => ::core::result::Result::Ok(__Field::__F18),
                            "item_values" => ::core::result::Result::Ok(__Field::__F19),
                            _ => ::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::v1_0::bmm::core::entity::range_constrained::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<::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<::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<_> = None;
                let mut __s15: ::core::option::Option<_> = None;
                let mut __s16: ::core::option::Option<_> = None;
                let mut __s17: ::core::option::Option<_> = None;
                let mut __s18: ::core::option::Option<_> = None;
                let mut __s19: ::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("ancestors"),
                                );
                            }
                            __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("package"),
                                );
                            }
                            __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("properties"),
                                );
                            }
                            __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("source_schema_id"),
                                );
                            }
                            __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("immediate_descendants"),
                                );
                            }
                            __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("constants"),
                                );
                            }
                            __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("functions"),
                                );
                            }
                            __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("procedures"),
                                );
                            }
                            __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("is_primitive"),
                                );
                            }
                            __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("is_abstract"),
                                );
                            }
                            __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("invariants"),
                                );
                            }
                            __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("creators"),
                                );
                            }
                            __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("converters"),
                                );
                            }
                            __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("feature_groups"),
                                );
                            }
                            __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("item_names"),
                                );
                            }
                            __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_values"),
                                );
                            }
                            __s19 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::range_constrained::bmm_enumeration::BmmEnumerationData {
name: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
documentation: __s1.flatten(),
extensions: __s2.flatten(),
ancestors: __s3,
package: __s4.flatten().ok_or_else(|| ::serde::de::Error::missing_field("package"))?,
properties: __s5.flatten(),
source_schema_id: __s6.flatten().ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
immediate_descendants: __s7,
is_override: __s8.flatten().ok_or_else(|| ::serde::de::Error::missing_field("is_override"))?,
constants: __s9.flatten(),
functions: __s10.flatten(),
procedures: __s11.flatten(),
is_primitive: __s12.flatten(),
is_abstract: __s13.flatten(),
invariants: __s14,
creators: __s15,
converters: __s16,
feature_groups: __s17,
item_names: __s18,
item_values: __s19,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_ENUMERATION",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::entity::range_constrained::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::v1_0::bmm::core::entity::range_constrained::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::v1_0::bmm::core::entity::range_constrained::bmm_enumeration::BmmEnumeration::BmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::range_constrained::bmm_enumeration::BmmEnumeration::BmmEnumerationInteger(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::range_constrained::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::v1_0::bmm::core::entity::range_constrained::bmm_enumeration::BmmEnumeration::BmmEnumeration(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::core::entity::range_constrained::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.ancestors.as_ref().is_some_and(|__v| !__v.is_empty()) { __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.constants.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.as_ref().is_some_and(|__v| !__v.is_empty()) { __n += 1; }
if self.converters.as_ref().is_some_and(|__v| !__v.is_empty()) { __n += 1; }
if self.feature_groups.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; }
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.ancestors && !__v.is_empty() { ::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.constants { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constants", __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 && !__v.is_empty() { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "creators", __v)?; }
if let Some(__v) = &self.converters && !__v.is_empty() { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "converters", __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.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::v1_0::bmm::core::entity::range_constrained::bmm_enumeration_integer::BmmEnumerationInteger {
fn deserialize<__D: ::serde::Deserializer<'de>>(__deserializer: __D) -> ::core::result::Result<Self, __D::Error> {
const __FIELDS: &[&str] = &["ancestors", "constants", "converters", "creators", "documentation", "extensions", "feature_groups", "functions", "immediate_descendants", "invariants", "is_abstract", "is_override", "is_primitive", "item_names", "item_values", "name", "package", "procedures", "properties", "source_schema_id"];
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),
"ancestors" => ::core::result::Result::Ok(__Field::__F3),
"package" => ::core::result::Result::Ok(__Field::__F4),
"properties" => ::core::result::Result::Ok(__Field::__F5),
"source_schema_id" => ::core::result::Result::Ok(__Field::__F6),
"immediate_descendants" => ::core::result::Result::Ok(__Field::__F7),
"is_override" => ::core::result::Result::Ok(__Field::__F8),
"constants" => ::core::result::Result::Ok(__Field::__F9),
"functions" => ::core::result::Result::Ok(__Field::__F10),
"procedures" => ::core::result::Result::Ok(__Field::__F11),
"is_primitive" => ::core::result::Result::Ok(__Field::__F12),
"is_abstract" => ::core::result::Result::Ok(__Field::__F13),
"invariants" => ::core::result::Result::Ok(__Field::__F14),
"creators" => ::core::result::Result::Ok(__Field::__F15),
"converters" => ::core::result::Result::Ok(__Field::__F16),
"feature_groups" => ::core::result::Result::Ok(__Field::__F17),
"item_names" => ::core::result::Result::Ok(__Field::__F18),
"item_values" => ::core::result::Result::Ok(__Field::__F19),
_ => ::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::v1_0::bmm::core::entity::range_constrained::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<::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<::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<_> = None;
let mut __s15: ::core::option::Option<_> = None;
let mut __s16: ::core::option::Option<_> = None;
let mut __s17: ::core::option::Option<_> = None;
let mut __s18: ::core::option::Option<_> = None;
let mut __s19: ::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("ancestors")); }
__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("package")); }
__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("properties")); }
__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("source_schema_id")); }
__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("immediate_descendants")); }
__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("constants")); }
__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("functions")); }
__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("procedures")); }
__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("is_primitive")); }
__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("is_abstract")); }
__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("invariants")); }
__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("creators")); }
__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("converters")); }
__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("feature_groups")); }
__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("item_names")); }
__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_values")); }
__s19 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
}
}
::core::result::Result::Ok(crate::v1_0::bmm::core::entity::range_constrained::bmm_enumeration_integer::BmmEnumerationInteger {
name: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
documentation: __s1.flatten(),
extensions: __s2.flatten(),
ancestors: __s3,
package: __s4.flatten().ok_or_else(|| ::serde::de::Error::missing_field("package"))?,
properties: __s5.flatten(),
source_schema_id: __s6.flatten().ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
immediate_descendants: __s7,
is_override: __s8.flatten().ok_or_else(|| ::serde::de::Error::missing_field("is_override"))?,
constants: __s9.flatten(),
functions: __s10.flatten(),
procedures: __s11.flatten(),
is_primitive: __s12.flatten(),
is_abstract: __s13.flatten(),
invariants: __s14,
creators: __s15,
converters: __s16,
feature_groups: __s17,
item_names: __s18,
item_values: __s19,
})
}
}
::serde::Deserializer::deserialize_struct(__deserializer, "BMM_ENUMERATION_INTEGER", __FIELDS, __Visitor)
}
}

impl ::serde::Serialize for crate::v1_0::bmm::core::entity::range_constrained::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.ancestors.as_ref().is_some_and(|__v| !__v.is_empty()) { __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.constants.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.as_ref().is_some_and(|__v| !__v.is_empty()) { __n += 1; }
if self.converters.as_ref().is_some_and(|__v| !__v.is_empty()) { __n += 1; }
if self.feature_groups.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; }
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.ancestors && !__v.is_empty() { ::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.constants { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constants", __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 && !__v.is_empty() { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "creators", __v)?; }
if let Some(__v) = &self.converters && !__v.is_empty() { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "converters", __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.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::v1_0::bmm::core::entity::range_constrained::bmm_enumeration_string::BmmEnumerationString {
fn deserialize<__D: ::serde::Deserializer<'de>>(__deserializer: __D) -> ::core::result::Result<Self, __D::Error> {
const __FIELDS: &[&str] = &["ancestors", "constants", "converters", "creators", "documentation", "extensions", "feature_groups", "functions", "immediate_descendants", "invariants", "is_abstract", "is_override", "is_primitive", "item_names", "item_values", "name", "package", "procedures", "properties", "source_schema_id"];
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),
"ancestors" => ::core::result::Result::Ok(__Field::__F3),
"package" => ::core::result::Result::Ok(__Field::__F4),
"properties" => ::core::result::Result::Ok(__Field::__F5),
"source_schema_id" => ::core::result::Result::Ok(__Field::__F6),
"immediate_descendants" => ::core::result::Result::Ok(__Field::__F7),
"is_override" => ::core::result::Result::Ok(__Field::__F8),
"constants" => ::core::result::Result::Ok(__Field::__F9),
"functions" => ::core::result::Result::Ok(__Field::__F10),
"procedures" => ::core::result::Result::Ok(__Field::__F11),
"is_primitive" => ::core::result::Result::Ok(__Field::__F12),
"is_abstract" => ::core::result::Result::Ok(__Field::__F13),
"invariants" => ::core::result::Result::Ok(__Field::__F14),
"creators" => ::core::result::Result::Ok(__Field::__F15),
"converters" => ::core::result::Result::Ok(__Field::__F16),
"feature_groups" => ::core::result::Result::Ok(__Field::__F17),
"item_names" => ::core::result::Result::Ok(__Field::__F18),
"item_values" => ::core::result::Result::Ok(__Field::__F19),
_ => ::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::v1_0::bmm::core::entity::range_constrained::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<::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<::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<_> = None;
let mut __s15: ::core::option::Option<_> = None;
let mut __s16: ::core::option::Option<_> = None;
let mut __s17: ::core::option::Option<_> = None;
let mut __s18: ::core::option::Option<_> = None;
let mut __s19: ::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("ancestors")); }
__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("package")); }
__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("properties")); }
__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("source_schema_id")); }
__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("immediate_descendants")); }
__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("constants")); }
__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("functions")); }
__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("procedures")); }
__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("is_primitive")); }
__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("is_abstract")); }
__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("invariants")); }
__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("creators")); }
__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("converters")); }
__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("feature_groups")); }
__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("item_names")); }
__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_values")); }
__s19 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
}
}
::core::result::Result::Ok(crate::v1_0::bmm::core::entity::range_constrained::bmm_enumeration_string::BmmEnumerationString {
name: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
documentation: __s1.flatten(),
extensions: __s2.flatten(),
ancestors: __s3,
package: __s4.flatten().ok_or_else(|| ::serde::de::Error::missing_field("package"))?,
properties: __s5.flatten(),
source_schema_id: __s6.flatten().ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
immediate_descendants: __s7,
is_override: __s8.flatten().ok_or_else(|| ::serde::de::Error::missing_field("is_override"))?,
constants: __s9.flatten(),
functions: __s10.flatten(),
procedures: __s11.flatten(),
is_primitive: __s12.flatten(),
is_abstract: __s13.flatten(),
invariants: __s14,
creators: __s15,
converters: __s16,
feature_groups: __s17,
item_names: __s18,
item_values: __s19,
})
}
}
::serde::Deserializer::deserialize_struct(__deserializer, "BMM_ENUMERATION_STRING", __FIELDS, __Visitor)
}
}

impl ::serde::Serialize
    for crate::v1_0::bmm::core::feature::bmm_feature_extension::BmmFeatureExtension
{
    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_FEATURE_EXTENSION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "BMM_FEATURE_EXTENSION",
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::feature::bmm_feature_extension::BmmFeatureExtension
{
    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_FEATURE_EXTENSION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_0::bmm::core::feature::bmm_feature_extension::BmmFeatureExtension;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_FEATURE_EXTENSION` 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_FEATURE_EXTENSION",
                                ),
                            )?;
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::core::feature::bmm_feature_extension::BmmFeatureExtension {},
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_FEATURE_EXTENSION",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::core::feature::bmm_function::BmmFunction {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 6usize;
        if self.is_nullable.is_some() {
            __n += 1;
        }
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_synthesised_generic.is_some() {
            __n += 1;
        }
        if self.visibility.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.locals.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.body.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, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        ::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)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "scope", &self.scope)?;
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __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.visibility {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "visibility", __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.locals
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "locals", __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.body {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "body", __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::v1_0::bmm::core::feature::bmm_function::BmmFunction {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "body",
            "documentation",
            "extensions",
            "feature_extensions",
            "group",
            "is_nullable",
            "is_synthesised_generic",
            "locals",
            "name",
            "operator_definition",
            "parameters",
            "post_conditions",
            "pre_conditions",
            "result",
            "scope",
            "type",
            "visibility",
        ];
        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),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F1),
                            "name" => ::core::result::Result::Ok(__Field::__F2),
                            "documentation" => ::core::result::Result::Ok(__Field::__F3),
                            "scope" => ::core::result::Result::Ok(__Field::__F4),
                            "extensions" => ::core::result::Result::Ok(__Field::__F5),
                            "is_synthesised_generic" => ::core::result::Result::Ok(__Field::__F6),
                            "visibility" => ::core::result::Result::Ok(__Field::__F7),
                            "feature_extensions" => ::core::result::Result::Ok(__Field::__F8),
                            "group" => ::core::result::Result::Ok(__Field::__F9),
                            "parameters" => ::core::result::Result::Ok(__Field::__F10),
                            "locals" => ::core::result::Result::Ok(__Field::__F11),
                            "pre_conditions" => ::core::result::Result::Ok(__Field::__F12),
                            "post_conditions" => ::core::result::Result::Ok(__Field::__F13),
                            "body" => ::core::result::Result::Ok(__Field::__F14),
                            "operator_definition" => ::core::result::Result::Ok(__Field::__F15),
                            "result" => ::core::result::Result::Ok(__Field::__F16),
                            _ => ::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::v1_0::bmm::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<::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<_> = None;
                let mut __s11: ::core::option::Option<_> = None;
                let mut __s12: ::core::option::Option<_> = None;
                let mut __s13: ::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("BMM_FUNCTION"),
                            )?;
                        }
                        __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("is_nullable"),
                                );
                            }
                            __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("documentation"),
                                );
                            }
                            __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("scope"),
                                );
                            }
                            __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("extensions"),
                                );
                            }
                            __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_synthesised_generic"),
                                );
                            }
                            __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("visibility"),
                                );
                            }
                            __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("feature_extensions"),
                                );
                            }
                            __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("group"),
                                );
                            }
                            __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("parameters"),
                                );
                            }
                            __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("locals"),
                                );
                            }
                            __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("pre_conditions"),
                                );
                            }
                            __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("post_conditions"),
                                );
                            }
                            __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("body"),
                                );
                            }
                            __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("operator_definition"),
                                );
                            }
                            __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("result"),
                                );
                            }
                            __s16 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::core::feature::bmm_function::BmmFunction {
                        r#type: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        is_nullable: __s1.flatten(),
                        name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s3.flatten(),
                        scope: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("scope"))?,
                        extensions: __s5.flatten(),
                        is_synthesised_generic: __s6.flatten(),
                        visibility: __s7.flatten(),
                        feature_extensions: __s8,
                        group: __s9
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("group"))?,
                        parameters: __s10,
                        locals: __s11,
                        pre_conditions: __s12,
                        post_conditions: __s13,
                        body: __s14.flatten(),
                        operator_definition: __s15.flatten(),
                        result: __s16
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("result"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_FUNCTION",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::core::entity::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.ancestors.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __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.constants.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.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.converters.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self
            .feature_groups
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __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.ancestors
            && !__v.is_empty()
        {
            ::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.constants {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constants", __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
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "creators", __v)?;
        }
        if let Some(__v) = &self.converters
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "converters", __v)?;
        }
        if let Some(__v) = &self.feature_groups
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "feature_groups", __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::v1_0::bmm::core::entity::bmm_generic_class::BmmGenericClass
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "ancestors",
            "constants",
            "converters",
            "creators",
            "documentation",
            "extensions",
            "feature_groups",
            "functions",
            "generic_parameters",
            "immediate_descendants",
            "invariants",
            "is_abstract",
            "is_override",
            "is_primitive",
            "name",
            "package",
            "procedures",
            "properties",
            "source_schema_id",
        ];
        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),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F3),
                            "package" => ::core::result::Result::Ok(__Field::__F4),
                            "properties" => ::core::result::Result::Ok(__Field::__F5),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F6),
                            "immediate_descendants" => ::core::result::Result::Ok(__Field::__F7),
                            "is_override" => ::core::result::Result::Ok(__Field::__F8),
                            "constants" => ::core::result::Result::Ok(__Field::__F9),
                            "functions" => ::core::result::Result::Ok(__Field::__F10),
                            "procedures" => ::core::result::Result::Ok(__Field::__F11),
                            "is_primitive" => ::core::result::Result::Ok(__Field::__F12),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F13),
                            "invariants" => ::core::result::Result::Ok(__Field::__F14),
                            "creators" => ::core::result::Result::Ok(__Field::__F15),
                            "converters" => ::core::result::Result::Ok(__Field::__F16),
                            "feature_groups" => ::core::result::Result::Ok(__Field::__F17),
                            "generic_parameters" => ::core::result::Result::Ok(__Field::__F18),
                            _ => ::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::v1_0::bmm::core::entity::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<::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<::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<_> = None;
                let mut __s15: ::core::option::Option<_> = None;
                let mut __s16: ::core::option::Option<_> = None;
                let mut __s17: ::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_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("ancestors"),
                                );
                            }
                            __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("package"),
                                );
                            }
                            __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("properties"),
                                );
                            }
                            __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("source_schema_id"),
                                );
                            }
                            __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("immediate_descendants"),
                                );
                            }
                            __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("constants"),
                                );
                            }
                            __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("functions"),
                                );
                            }
                            __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("procedures"),
                                );
                            }
                            __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("is_primitive"),
                                );
                            }
                            __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("is_abstract"),
                                );
                            }
                            __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("invariants"),
                                );
                            }
                            __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("creators"),
                                );
                            }
                            __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("converters"),
                                );
                            }
                            __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("feature_groups"),
                                );
                            }
                            __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("generic_parameters"),
                                );
                            }
                            __s18 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::core::entity::bmm_generic_class::BmmGenericClass {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s1.flatten(),
                        extensions: __s2.flatten(),
                        ancestors: __s3,
                        package: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("package"))?,
                        properties: __s5.flatten(),
                        source_schema_id: __s6
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                        immediate_descendants: __s7,
                        is_override: __s8
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_override"))?,
                        constants: __s9.flatten(),
                        functions: __s10.flatten(),
                        procedures: __s11.flatten(),
                        is_primitive: __s12.flatten(),
                        is_abstract: __s13.flatten(),
                        invariants: __s14,
                        creators: __s15,
                        converters: __s16,
                        feature_groups: __s17,
                        generic_parameters: __s18.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::v1_0::bmm::core::entity::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::v1_0::bmm::core::entity::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::v1_0::bmm::core::entity::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::v1_0::bmm::core::entity::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::v1_0::bmm_persistence::bmm_include_spec::BmmIncludeSpec {
    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_INCLUDE_SPEC", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_INCLUDE_SPEC")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "id", &self.id)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm_persistence::bmm_include_spec::BmmIncludeSpec
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["id"];
        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),
                            "id" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_INCLUDE_SPEC",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm_persistence::bmm_include_spec::BmmIncludeSpec;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_INCLUDE_SPEC` 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_INCLUDE_SPEC"),
                            )?;
                        }
                        __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)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm_persistence::bmm_include_spec::BmmIncludeSpec {
                        id: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("id"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_INCLUDE_SPEC",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::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 = 5usize;
        if self.is_nullable.is_some() {
            __n += 1;
        }
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_synthesised_generic.is_some() {
            __n += 1;
        }
        if self.visibility.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, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        ::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)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "scope", &self.scope)?;
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __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.visibility {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "visibility", __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::v1_0::bmm::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",
            "scope",
            "type",
            "visibility",
        ];
        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),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F1),
                            "name" => ::core::result::Result::Ok(__Field::__F2),
                            "documentation" => ::core::result::Result::Ok(__Field::__F3),
                            "scope" => ::core::result::Result::Ok(__Field::__F4),
                            "extensions" => ::core::result::Result::Ok(__Field::__F5),
                            "is_synthesised_generic" => ::core::result::Result::Ok(__Field::__F6),
                            "visibility" => ::core::result::Result::Ok(__Field::__F7),
                            "feature_extensions" => ::core::result::Result::Ok(__Field::__F8),
                            "group" => ::core::result::Result::Ok(__Field::__F9),
                            "is_im_runtime" => ::core::result::Result::Ok(__Field::__F10),
                            "is_im_infrastructure" => ::core::result::Result::Ok(__Field::__F11),
                            "is_composition" => ::core::result::Result::Ok(__Field::__F12),
                            "cardinality" => ::core::result::Result::Ok(__Field::__F13),
                            _ => ::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::v1_0::bmm::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<::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<::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_INDEXED_CONTAINER_PROPERTY",
                                ),
                            )?;
                        }
                        __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("is_nullable"),
                                );
                            }
                            __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("documentation"),
                                );
                            }
                            __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("scope"),
                                );
                            }
                            __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("extensions"),
                                );
                            }
                            __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_synthesised_generic"),
                                );
                            }
                            __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("visibility"),
                                );
                            }
                            __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("feature_extensions"),
                                );
                            }
                            __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("group"),
                                );
                            }
                            __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_im_runtime"),
                                );
                            }
                            __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("is_im_infrastructure"),
                                );
                            }
                            __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("is_composition"),
                                );
                            }
                            __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("cardinality"),
                                );
                            }
                            __s13 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_indexed_container_property::BmmIndexedContainerProperty {
r#type: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
is_nullable: __s1.flatten(),
name: __s2.flatten().ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
documentation: __s3.flatten(),
scope: __s4.flatten().ok_or_else(|| ::serde::de::Error::missing_field("scope"))?,
extensions: __s5.flatten(),
is_synthesised_generic: __s6.flatten(),
visibility: __s7.flatten(),
feature_extensions: __s8,
group: __s9.flatten().ok_or_else(|| ::serde::de::Error::missing_field("group"))?,
is_im_runtime: __s10.flatten(),
is_im_infrastructure: __s11.flatten(),
is_composition: __s12.flatten(),
cardinality: __s13.flatten(),
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_INDEXED_CONTAINER_PROPERTY",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::core::entity::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::v1_0::bmm::core::entity::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::v1_0::bmm::core::entity::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::v1_0::bmm::core::entity::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::v1_0::bmm::core::literal_value::bmm_indexed_container_value::BmmIndexedContainerValue
{
    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_INDEXED_CONTAINER_VALUE",
            __n,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "BMM_INDEXED_CONTAINER_VALUE",
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        ::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::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::literal_value::bmm_indexed_container_value::BmmIndexedContainerValue
{
    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),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "value_literal" => ::core::result::Result::Ok(__Field::__F1),
                            "value" => ::core::result::Result::Ok(__Field::__F2),
                            "syntax" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_INDEXED_CONTAINER_VALUE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::core::literal_value::bmm_indexed_container_value::BmmIndexedContainerValue;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_INDEXED_CONTAINER_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_INDEXED_CONTAINER_VALUE",
                                ),
                            )?;
                        }
                        __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("value_literal"),
                                );
                            }
                            __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("value"),
                                );
                            }
                            __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("syntax"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_0::bmm::core::literal_value::bmm_indexed_container_value::BmmIndexedContainerValue {
r#type: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
value_literal: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("value_literal"))?,
value: __s2.flatten(),
syntax: __s3.flatten(),
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_INDEXED_CONTAINER_VALUE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::core::feature::bmm_instantiable::BmmInstantiable {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_0::bmm::core::feature::bmm_instantiable::BmmInstantiable::BmmConstant(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_instantiable::BmmInstantiable::BmmContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_instantiable::BmmInstantiable::BmmLocal(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_instantiable::BmmInstantiable::BmmParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_instantiable::BmmInstantiable::BmmResult(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_instantiable::BmmInstantiable::BmmUnitaryProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::feature::bmm_instantiable::BmmInstantiable
{
    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_LOCAL",
            "BMM_PARAMETER",
            "BMM_RESULT",
            "BMM_UNITARY_PROPERTY",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::core::feature::bmm_instantiable::BmmInstantiable;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_INSTANTIABLE` 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::v1_0::bmm::core::feature::bmm_instantiable::BmmInstantiable::BmmConstant(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_instantiable::BmmInstantiable::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_instantiable::BmmInstantiable::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_LOCAL" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_instantiable::BmmInstantiable::BmmLocal(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PARAMETER" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_instantiable::BmmInstantiable::BmmParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_RESULT" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_instantiable::BmmInstantiable::BmmResult(::serde::Deserialize::deserialize(__rest)?)),
"BMM_UNITARY_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_instantiable::BmmInstantiable::BmmUnitaryProperty(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_INSTANTIABLE", __other, "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_PARAMETER, BMM_RESULT, BMM_UNITARY_PROPERTY")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_INSTANTIABLE",
                            &__other,
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_PARAMETER, BMM_RESULT, BMM_UNITARY_PROPERTY",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_INSTANTIABLE",
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_PARAMETER, BMM_RESULT, BMM_UNITARY_PROPERTY",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::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, "type", &self.r#type)?;
        ::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::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::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),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "value_literal" => ::core::result::Result::Ok(__Field::__F1),
                            "value" => ::core::result::Result::Ok(__Field::__F2),
                            "syntax" => ::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::v1_0::bmm::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("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_literal"),
                                );
                            }
                            __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("value"),
                                );
                            }
                            __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("syntax"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::core::literal_value::bmm_integer_value::BmmIntegerValue {
                        r#type: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        value_literal: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("value_literal"))?,
                        value: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("value"))?,
                        syntax: __s3.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_INTEGER_VALUE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::core::literal_value::bmm_interval_value::BmmIntervalValue
{
    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_INTERVAL_VALUE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_INTERVAL_VALUE")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        ::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::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::literal_value::bmm_interval_value::BmmIntervalValue
{
    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),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "value_literal" => ::core::result::Result::Ok(__Field::__F1),
                            "value" => ::core::result::Result::Ok(__Field::__F2),
                            "syntax" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_INTERVAL_VALUE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_0::bmm::core::literal_value::bmm_interval_value::BmmIntervalValue;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_INTERVAL_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_INTERVAL_VALUE"),
                            )?;
                        }
                        __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("value_literal"),
                                );
                            }
                            __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("value"),
                                );
                            }
                            __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("syntax"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::core::literal_value::bmm_interval_value::BmmIntervalValue {
                        r#type: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        value_literal: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("value_literal"))?,
                        value: __s2.flatten(),
                        syntax: __s3.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_INTERVAL_VALUE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::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::v1_0::bmm::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmContainerValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmIntervalValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmPrimitiveValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_VALUE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmContainerValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_VALUE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmContainerValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INTEGER_VALUE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INTERVAL_VALUE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmIntervalValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PRIMITIVE_VALUE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STRING_VALUE" => ::core::result::Result::Ok(crate::v1_0::bmm::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::v1_0::bmm::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.is_nullable.is_some() {
            __n += 1;
        }
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_synthesised_generic.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, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        ::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.is_synthesised_generic {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_synthesised_generic",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::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",
            "is_synthesised_generic",
            "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),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F1),
                            "name" => ::core::result::Result::Ok(__Field::__F2),
                            "documentation" => ::core::result::Result::Ok(__Field::__F3),
                            "extensions" => ::core::result::Result::Ok(__Field::__F4),
                            "is_synthesised_generic" => ::core::result::Result::Ok(__Field::__F5),
                            _ => ::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::v1_0::bmm::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;
                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_LOCAL"),
                            )?;
                        }
                        __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("is_nullable"),
                                );
                            }
                            __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("documentation"),
                                );
                            }
                            __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("extensions"),
                                );
                            }
                            __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)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_local::BmmLocal {
                    r#type: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                    is_nullable: __s1.flatten(),
                    name: __s2
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                    documentation: __s3.flatten(),
                    extensions: __s4.flatten(),
                    is_synthesised_generic: __s5.flatten(),
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "BMM_LOCAL", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::core::model::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;
        }
        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)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::core::model::bmm_model::BmmModel {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "class_definitions",
            "documentation",
            "extensions",
            "name",
            "packages",
            "rm_publisher",
            "rm_release",
            "used_models",
        ];
        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),
                            "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),
                            _ => ::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::v1_0::bmm::core::model::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;
                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)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_0::bmm::core::model::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,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "BMM_MODEL", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::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.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.bmm_models.is_some() {
            __n += 1;
        }
        if self
            .matching_bmm_models
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __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
            && !__v.is_empty()
        {
            ::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
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "matching_bmm_models", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::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::v1_0::bmm::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<_> = 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("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::v1_0::bmm::model_access::bmm_model_access::BmmModelAccess {
                        schema_directories: __s0,
                        all_schemas: __s1,
                        bmm_models: __s2.flatten(),
                        matching_bmm_models: __s3,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_MODEL_ACCESS",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::core::model::bmm_model_metadata::BmmModelMetadata {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_0::bmm::core::model::bmm_model_metadata::BmmModelMetadata::BmmModel(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::model::bmm_model_metadata::BmmModelMetadata::PBmmSchema(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::model::bmm_model_metadata::BmmModelMetadata::BmmModelMetadata(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::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", "P_BMM_SCHEMA"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::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::v1_0::bmm::core::model::bmm_model_metadata::BmmModelMetadata::BmmModel(::serde::Deserialize::deserialize(__rest)?)),
"BMM_MODEL_METADATA" => ::core::result::Result::Ok(crate::v1_0::bmm::core::model::bmm_model_metadata::BmmModelMetadata::BmmModelMetadata(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SCHEMA" => ::core::result::Result::Ok(crate::v1_0::bmm::core::model::bmm_model_metadata::BmmModelMetadata::PBmmSchema(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_MODEL_METADATA", __other, "BMM_MODEL, BMM_MODEL_METADATA, P_BMM_SCHEMA")),
}
                    }
                    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, P_BMM_SCHEMA",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v1_0::bmm::core::model::bmm_model_metadata::BmmModelMetadata::BmmModelMetadata(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::core::entity::bmm_model_type::BmmModelType::BmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v1_0::bmm::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::v1_0::bmm::core::entity::bmm_module::BmmModule {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_0::bmm::core::entity::bmm_module::BmmModule::BmmGenericClass(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::core::entity::bmm_module::BmmModule::BmmSimpleClass(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::core::entity::bmm_module::BmmModule::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::bmm_module::BmmModule::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::bmm_module::BmmModule::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_CLASS" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::bmm_module::BmmModule::BmmGenericClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_CLASS" => ::core::result::Result::Ok(crate::v1_0::bmm::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::v1_0::bmm::core::feature::bmm_operator::BmmOperator {
    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_OPERATOR", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_OPERATOR")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "position", &self.position)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "symbols", &self.symbols)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::core::feature::bmm_operator::BmmOperator {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["name", "position", "symbols"];
        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),
                            "position" => ::core::result::Result::Ok(__Field::__F0),
                            "symbols" => ::core::result::Result::Ok(__Field::__F1),
                            "name" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_OPERATOR",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::core::feature::bmm_operator::BmmOperator;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_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;
                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_OPERATOR"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("position"),
                                );
                            }
                            __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("symbols"),
                                );
                            }
                            __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)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::core::feature::bmm_operator::BmmOperator {
                        position: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("position"))?,
                        symbols: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("symbols"))?,
                        name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_OPERATOR",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::core::feature::bmm_operator_position::BmmOperatorPosition
{
    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_0::bmm::core::feature::bmm_operator_position::BmmOperatorPosition
{
    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_0::bmm::core::feature::bmm_operator_position::BmmOperatorPosition;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("a `BmmOperatorPosition` token")
            }
            fn visit_str<__E: ::serde::de::Error>(
                self,
                __v: &str,
            ) -> ::core::result::Result<Self::Value, __E> {
                ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_operator_position::BmmOperatorPosition::from_wire(__v))
            }
        }
        ::serde::Deserializer::deserialize_str(__deserializer, __V)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::core::model::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.classes.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.classes
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "classes", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::core::model::bmm_package::BmmPackage {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["classes", "documentation", "extensions", "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),
                            "classes" => ::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::v1_0::bmm::core::model::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("classes"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_0::bmm::core::model::bmm_package::BmmPackage {
                    name: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                    documentation: __s1.flatten(),
                    extensions: __s2.flatten(),
                    packages: __s3.flatten(),
                    classes: __s4,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_PACKAGE",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::model::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::v1_0::bmm::core::model::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::v1_0::bmm::core::model::bmm_package_container::BmmPackageContainer::BmmModel(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PACKAGE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::model::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::v1_0::bmm::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.is_nullable.is_some() {
            __n += 1;
        }
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_synthesised_generic.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, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        ::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.is_synthesised_generic {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_synthesised_generic",
                __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::v1_0::bmm::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",
            "is_synthesised_generic",
            "name",
            "type",
        ];
        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),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F1),
                            "name" => ::core::result::Result::Ok(__Field::__F2),
                            "documentation" => ::core::result::Result::Ok(__Field::__F3),
                            "extensions" => ::core::result::Result::Ok(__Field::__F4),
                            "is_synthesised_generic" => ::core::result::Result::Ok(__Field::__F5),
                            "direction" => ::core::result::Result::Ok(__Field::__F6),
                            _ => ::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::v1_0::bmm::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;
                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("BMM_PARAMETER"),
                            )?;
                        }
                        __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("is_nullable"),
                                );
                            }
                            __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("documentation"),
                                );
                            }
                            __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("extensions"),
                                );
                            }
                            __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("direction"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::core::feature::bmm_parameter::BmmParameter {
                        r#type: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        is_nullable: __s1.flatten(),
                        name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s3.flatten(),
                        extensions: __s4.flatten(),
                        is_synthesised_generic: __s5.flatten(),
                        direction: __s6.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_PARAMETER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::core::feature::bmm_parameter_direction::BmmParameterDirection
{
    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_0::bmm::core::feature::bmm_parameter_direction::BmmParameterDirection
{
    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_0::bmm::core::feature::bmm_parameter_direction::BmmParameterDirection;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("a `BmmParameterDirection` token")
            }
            fn visit_str<__E: ::serde::de::Error>(
                self,
                __v: &str,
            ) -> ::core::result::Result<Self::Value, __E> {
                ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_parameter_direction::BmmParameterDirection::from_wire(__v))
            }
        }
        ::serde::Deserializer::deserialize_str(__deserializer, __V)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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, "type", &self.r#type)?;
        ::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::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::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),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "value_literal" => ::core::result::Result::Ok(__Field::__F1),
                            "value" => ::core::result::Result::Ok(__Field::__F2),
                            "syntax" => ::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::v1_0::bmm::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("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_literal"),
                                );
                            }
                            __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("value"),
                                );
                            }
                            __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("syntax"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_0::bmm::core::literal_value::bmm_primitive_value::BmmPrimitiveValueData {
r#type: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
value_literal: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("value_literal"))?,
value: __s2.flatten(),
syntax: __s3.flatten(),
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_PRIMITIVE_VALUE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::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::v1_0::bmm::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmBooleanValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmIntegerValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmStringValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmPrimitiveValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmBooleanValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INTEGER_VALUE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmIntegerValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PRIMITIVE_VALUE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STRING_VALUE" => ::core::result::Result::Ok(crate::v1_0::bmm::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::v1_0::bmm::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::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_synthesised_generic.is_some() {
            __n += 1;
        }
        if self.visibility.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.locals.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.body.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)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "scope", &self.scope)?;
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __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.visibility {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "visibility", __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.locals
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "locals", __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.body {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "body", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::feature::bmm_procedure::BmmProcedure
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "body",
            "documentation",
            "extensions",
            "feature_extensions",
            "group",
            "is_synthesised_generic",
            "locals",
            "name",
            "parameters",
            "post_conditions",
            "pre_conditions",
            "scope",
            "visibility",
        ];
        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),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "scope" => ::core::result::Result::Ok(__Field::__F2),
                            "extensions" => ::core::result::Result::Ok(__Field::__F3),
                            "is_synthesised_generic" => ::core::result::Result::Ok(__Field::__F4),
                            "visibility" => ::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),
                            "locals" => ::core::result::Result::Ok(__Field::__F9),
                            "pre_conditions" => ::core::result::Result::Ok(__Field::__F10),
                            "post_conditions" => ::core::result::Result::Ok(__Field::__F11),
                            "body" => ::core::result::Result::Ok(__Field::__F12),
                            _ => ::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::v1_0::bmm::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<_> = 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("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("scope"),
                                );
                            }
                            __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("extensions"),
                                );
                            }
                            __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_synthesised_generic"),
                                );
                            }
                            __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("visibility"),
                                );
                            }
                            __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("locals"),
                                );
                            }
                            __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("pre_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("post_conditions"),
                                );
                            }
                            __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("body"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::core::feature::bmm_procedure::BmmProcedure {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s1.flatten(),
                        scope: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("scope"))?,
                        extensions: __s3.flatten(),
                        is_synthesised_generic: __s4.flatten(),
                        visibility: __s5.flatten(),
                        feature_extensions: __s6,
                        group: __s7
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("group"))?,
                        parameters: __s8,
                        locals: __s9,
                        pre_conditions: __s10,
                        post_conditions: __s11,
                        body: __s12.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_PROCEDURE",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::core::feature::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::v1_0::bmm::core::feature::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::v1_0::bmm::core::feature::bmm_property::BmmProperty::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_property::BmmProperty::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_UNITARY_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::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::v1_0::bmm::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.is_nullable.is_some() {
            __n += 1;
        }
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_synthesised_generic.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, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        ::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.is_synthesised_generic {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "is_synthesised_generic",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::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",
            "is_synthesised_generic",
            "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),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F1),
                            "name" => ::core::result::Result::Ok(__Field::__F2),
                            "documentation" => ::core::result::Result::Ok(__Field::__F3),
                            "extensions" => ::core::result::Result::Ok(__Field::__F4),
                            "is_synthesised_generic" => ::core::result::Result::Ok(__Field::__F5),
                            _ => ::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::v1_0::bmm::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;
                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_RESULT"),
                            )?;
                        }
                        __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("is_nullable"),
                                );
                            }
                            __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("documentation"),
                                );
                            }
                            __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("extensions"),
                                );
                            }
                            __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)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_result::BmmResult {
                    r#type: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                    is_nullable: __s1.flatten(),
                    name: __s2
                        .flatten()
                        .unwrap_or(::std::string::String::from("Result")),
                    documentation: __s3.flatten(),
                    extensions: __s4.flatten(),
                    is_synthesised_generic: __s5.flatten(),
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "BMM_RESULT", __FIELDS, __Visitor)
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::core::feature::bmm_routine::BmmRoutine::BmmFunction(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE" => ::core::result::Result::Ok(crate::v1_0::bmm::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::v1_0::bmm::core::feature::bmm_routine_body::BmmRoutineBody {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_0::bmm::core::feature::bmm_routine_body::BmmRoutineBody::BmmActionTable(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_routine_body::BmmRoutineBody::BmmAssertion(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_routine_body::BmmRoutineBody::BmmAssignment(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_routine_body::BmmRoutineBody::BmmProcedureCall(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_routine_body::BmmRoutineBody::BmmRoutineExternal(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_routine_body::BmmRoutineBody::BmmStatementBlock(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::feature::bmm_routine_body::BmmRoutineBody
{
    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_PROCEDURE_CALL",
            "BMM_ROUTINE_EXTERNAL",
            "BMM_STATEMENT_BLOCK",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::core::feature::bmm_routine_body::BmmRoutineBody;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_ROUTINE_BODY` 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::v1_0::bmm::core::feature::bmm_routine_body::BmmRoutineBody::BmmActionTable(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ASSERTION" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_routine_body::BmmRoutineBody::BmmAssertion(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ASSIGNMENT" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_routine_body::BmmRoutineBody::BmmAssignment(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_CALL" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_routine_body::BmmRoutineBody::BmmProcedureCall(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ROUTINE_EXTERNAL" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_routine_body::BmmRoutineBody::BmmRoutineExternal(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STATEMENT_BLOCK" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_routine_body::BmmRoutineBody::BmmStatementBlock(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_ROUTINE_BODY", __other, "BMM_ACTION_TABLE, BMM_ASSERTION, BMM_ASSIGNMENT, BMM_PROCEDURE_CALL, BMM_ROUTINE_EXTERNAL, BMM_STATEMENT_BLOCK")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_ROUTINE_BODY",
                            &__other,
                            "BMM_ACTION_TABLE, BMM_ASSERTION, BMM_ASSIGNMENT, BMM_PROCEDURE_CALL, BMM_ROUTINE_EXTERNAL, BMM_STATEMENT_BLOCK",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_ROUTINE_BODY",
                            "BMM_ACTION_TABLE, BMM_ASSERTION, BMM_ASSIGNMENT, BMM_PROCEDURE_CALL, BMM_ROUTINE_EXTERNAL, BMM_STATEMENT_BLOCK",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::core::feature::bmm_routine_external::BmmRoutineExternal
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.argument_mapping.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_ROUTINE_EXTERNAL", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_ROUTINE_EXTERNAL")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "meta_data", &self.meta_data)?;
        if let Some(__v) = &self.argument_mapping {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "argument_mapping", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::feature::bmm_routine_external::BmmRoutineExternal
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["argument_mapping", "meta_data"];
        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),
                            "meta_data" => ::core::result::Result::Ok(__Field::__F0),
                            "argument_mapping" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_ROUTINE_EXTERNAL",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::core::feature::bmm_routine_external::BmmRoutineExternal;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_ROUTINE_EXTERNAL` 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_EXTERNAL"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("meta_data"),
                                );
                            }
                            __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_mapping"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::core::feature::bmm_routine_external::BmmRoutineExternal {
                        meta_data: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("meta_data"))?,
                        argument_mapping: __s1.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_ROUTINE_EXTERNAL",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::model_access::bmm_schema::BmmSchema {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["P_BMM_SCHEMA"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::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 (__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" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::model_access::bmm_schema::BmmSchema::PBmmSchema(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            __other => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unexpected_type(
                                    "BMM_SCHEMA",
                                    __other,
                                    "P_BMM_SCHEMA",
                                ),
                            ),
                        }
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_SCHEMA",
                            &__other,
                            "P_BMM_SCHEMA",
                        ))
                    }
                    None => ::core::result::Result::Err(
                        ::openehr_base::serde_support::missing_type("BMM_SCHEMA", "P_BMM_SCHEMA"),
                    ),
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::model_access::bmm_schema_descriptor::BmmSchemaDescriptor
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_0::bmm::model_access::bmm_schema_descriptor::BmmSchemaDescriptor::PBmmSchemaDescriptor(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::model_access::bmm_schema_descriptor::BmmSchemaDescriptor
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["P_BMM_SCHEMA_DESCRIPTOR"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::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 (__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::v1_0::bmm::model_access::bmm_schema_descriptor::BmmSchemaDescriptor::PBmmSchemaDescriptor(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_SCHEMA_DESCRIPTOR", __other, "P_BMM_SCHEMA_DESCRIPTOR")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_SCHEMA_DESCRIPTOR",
                            &__other,
                            "P_BMM_SCHEMA_DESCRIPTOR",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_SCHEMA_DESCRIPTOR",
                            "P_BMM_SCHEMA_DESCRIPTOR",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::model_access::bmm_schema_metadata_key::BmmSchemaMetadataKey
{
    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_0::bmm::model_access::bmm_schema_metadata_key::BmmSchemaMetadataKey
{
    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_0::bmm::model_access::bmm_schema_metadata_key::BmmSchemaMetadataKey;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("a `BmmSchemaMetadataKey` token")
            }
            fn visit_str<__E: ::serde::de::Error>(
                self,
                __v: &str,
            ) -> ::core::result::Result<Self::Value, __E> {
                ::core::result::Result::Ok(crate::v1_0::bmm::model_access::bmm_schema_metadata_key::BmmSchemaMetadataKey::from_wire(__v))
            }
        }
        ::serde::Deserializer::deserialize_str(__deserializer, __V)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::model_access::bmm_schema_state::BmmSchemaState {
    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_0::bmm::model_access::bmm_schema_state::BmmSchemaState
{
    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_0::bmm::model_access::bmm_schema_state::BmmSchemaState;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("a `BmmSchemaState` token")
            }
            fn visit_str<__E: ::serde::de::Error>(
                self,
                __v: &str,
            ) -> ::core::result::Result<Self::Value, __E> {
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::model_access::bmm_schema_state::BmmSchemaState::from_wire(
                        __v,
                    ),
                )
            }
        }
        ::serde::Deserializer::deserialize_str(__deserializer, __V)
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::entity::bmm_signature::BmmSignature
{
    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),
                            "argument_types" => ::core::result::Result::Ok(__Field::__F0),
                            "result_type" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::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::v1_0::bmm::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 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_SIGNATURE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("argument_types"),
                                );
                            }
                            __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_type"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::core::entity::bmm_signature::BmmSignature {
                        argument_types: __s0.flatten(),
                        result_type: __s1.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_SIGNATURE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::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.ancestors.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __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.constants.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.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self.converters.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        if self
            .feature_groups
            .as_ref()
            .is_some_and(|__v| !__v.is_empty())
        {
            __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.ancestors
            && !__v.is_empty()
        {
            ::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.constants {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "constants", __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
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "creators", __v)?;
        }
        if let Some(__v) = &self.converters
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "converters", __v)?;
        }
        if let Some(__v) = &self.feature_groups
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "feature_groups", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::entity::bmm_simple_class::BmmSimpleClassData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "ancestors",
            "constants",
            "converters",
            "creators",
            "documentation",
            "extensions",
            "feature_groups",
            "functions",
            "immediate_descendants",
            "invariants",
            "is_abstract",
            "is_override",
            "is_primitive",
            "name",
            "package",
            "procedures",
            "properties",
            "source_schema_id",
        ];
        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),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "documentation" => ::core::result::Result::Ok(__Field::__F1),
                            "extensions" => ::core::result::Result::Ok(__Field::__F2),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F3),
                            "package" => ::core::result::Result::Ok(__Field::__F4),
                            "properties" => ::core::result::Result::Ok(__Field::__F5),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F6),
                            "immediate_descendants" => ::core::result::Result::Ok(__Field::__F7),
                            "is_override" => ::core::result::Result::Ok(__Field::__F8),
                            "constants" => ::core::result::Result::Ok(__Field::__F9),
                            "functions" => ::core::result::Result::Ok(__Field::__F10),
                            "procedures" => ::core::result::Result::Ok(__Field::__F11),
                            "is_primitive" => ::core::result::Result::Ok(__Field::__F12),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F13),
                            "invariants" => ::core::result::Result::Ok(__Field::__F14),
                            "creators" => ::core::result::Result::Ok(__Field::__F15),
                            "converters" => ::core::result::Result::Ok(__Field::__F16),
                            "feature_groups" => ::core::result::Result::Ok(__Field::__F17),
                            _ => ::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::v1_0::bmm::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<::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<::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<_> = None;
                let mut __s15: ::core::option::Option<_> = None;
                let mut __s16: ::core::option::Option<_> = None;
                let mut __s17: ::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("ancestors"),
                                );
                            }
                            __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("package"),
                                );
                            }
                            __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("properties"),
                                );
                            }
                            __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("source_schema_id"),
                                );
                            }
                            __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("immediate_descendants"),
                                );
                            }
                            __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("constants"),
                                );
                            }
                            __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("functions"),
                                );
                            }
                            __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("procedures"),
                                );
                            }
                            __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("is_primitive"),
                                );
                            }
                            __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("is_abstract"),
                                );
                            }
                            __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("invariants"),
                                );
                            }
                            __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("creators"),
                                );
                            }
                            __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("converters"),
                                );
                            }
                            __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("feature_groups"),
                                );
                            }
                            __s17 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::core::entity::bmm_simple_class::BmmSimpleClassData {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s1.flatten(),
                        extensions: __s2.flatten(),
                        ancestors: __s3,
                        package: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("package"))?,
                        properties: __s5.flatten(),
                        source_schema_id: __s6
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                        immediate_descendants: __s7,
                        is_override: __s8
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_override"))?,
                        constants: __s9.flatten(),
                        functions: __s10.flatten(),
                        procedures: __s11.flatten(),
                        is_primitive: __s12.flatten(),
                        is_abstract: __s13.flatten(),
                        invariants: __s14,
                        creators: __s15,
                        converters: __s16,
                        feature_groups: __s17,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_SIMPLE_CLASS",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::core::entity::bmm_simple_class::BmmSimpleClass::BmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::bmm_simple_class::BmmSimpleClass::BmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::bmm_simple_class::BmmSimpleClass::BmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_CLASS" => ::core::result::Result::Ok(crate::v1_0::bmm::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::v1_0::bmm::core::entity::bmm_simple_class::BmmSimpleClass::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::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_PROCEDURE_CALL"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::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::v1_0::bmm::statement::bmm_simple_statement::BmmSimpleStatement::BmmAssertion(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ASSIGNMENT" => ::core::result::Result::Ok(crate::v1_0::bmm::statement::bmm_simple_statement::BmmSimpleStatement::BmmAssignment(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_CALL" => ::core::result::Result::Ok(crate::v1_0::bmm::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_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_PROCEDURE_CALL",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_SIMPLE_STATEMENT",
                            "BMM_ASSERTION, BMM_ASSIGNMENT, BMM_PROCEDURE_CALL",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::core::entity::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::v1_0::bmm::core::entity::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::v1_0::bmm::core::entity::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::v1_0::bmm::core::entity::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::v1_0::bmm::statement::bmm_statement::BmmStatement {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_0::bmm::statement::bmm_statement::BmmStatement::BmmActionTable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::statement::bmm_statement::BmmStatement::BmmAssertion(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::statement::bmm_statement::BmmStatement::BmmAssignment(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::statement::bmm_statement::BmmStatement::BmmProcedureCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::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_PROCEDURE_CALL",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::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::v1_0::bmm::statement::bmm_statement::BmmStatement::BmmActionTable(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ASSERTION" => ::core::result::Result::Ok(crate::v1_0::bmm::statement::bmm_statement::BmmStatement::BmmAssertion(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ASSIGNMENT" => ::core::result::Result::Ok(crate::v1_0::bmm::statement::bmm_statement::BmmStatement::BmmAssignment(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_CALL" => ::core::result::Result::Ok(crate::v1_0::bmm::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_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_PROCEDURE_CALL",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_STATEMENT",
                            "BMM_ACTION_TABLE, BMM_ASSERTION, BMM_ASSIGNMENT, BMM_PROCEDURE_CALL",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::statement::bmm_statement_block::BmmStatementBlock {
                        items: __s0,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_STATEMENT_BLOCK",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::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_PROCEDURE_CALL",
            "BMM_STATEMENT_BLOCK",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::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::v1_0::bmm::statement::bmm_statement_item::BmmStatementItem::BmmActionTable(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ASSERTION" => ::core::result::Result::Ok(crate::v1_0::bmm::statement::bmm_statement_item::BmmStatementItem::BmmAssertion(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ASSIGNMENT" => ::core::result::Result::Ok(crate::v1_0::bmm::statement::bmm_statement_item::BmmStatementItem::BmmAssignment(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_CALL" => ::core::result::Result::Ok(crate::v1_0::bmm::statement::bmm_statement_item::BmmStatementItem::BmmProcedureCall(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STATEMENT_BLOCK" => ::core::result::Result::Ok(crate::v1_0::bmm::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_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_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_PROCEDURE_CALL, BMM_STATEMENT_BLOCK",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::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, "type", &self.r#type)?;
        ::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::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::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),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "value_literal" => ::core::result::Result::Ok(__Field::__F1),
                            "value" => ::core::result::Result::Ok(__Field::__F2),
                            "syntax" => ::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::v1_0::bmm::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("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_literal"),
                                );
                            }
                            __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("value"),
                                );
                            }
                            __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("syntax"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::core::literal_value::bmm_string_value::BmmStringValue {
                        r#type: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        value_literal: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("value_literal"))?,
                        value: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("value"))?,
                        syntax: __s3.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_STRING_VALUE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::core::entity::bmm_type::BmmType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_0::bmm::core::entity::bmm_type::BmmType::BmmContainerType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::core::entity::bmm_type::BmmType::BmmGenericType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::core::entity::bmm_type::BmmType::BmmParameterType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::core::entity::bmm_type::BmmType::BmmSignature(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::core::entity::bmm_type::BmmType::BmmSimpleType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::core::entity::bmm_type::BmmType::BmmTupleType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::core::entity::bmm_type::BmmType {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_CONTAINER_TYPE",
            "BMM_GENERIC_TYPE",
            "BMM_INDEXED_CONTAINER_TYPE",
            "BMM_PARAMETER_TYPE",
            "BMM_SIGNATURE",
            "BMM_SIMPLE_TYPE",
            "BMM_TUPLE_TYPE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::core::entity::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::v1_0::bmm::core::entity::bmm_type::BmmType::BmmContainerType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_GENERIC_TYPE" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::entity::bmm_type::BmmType::BmmGenericType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::entity::bmm_type::BmmType::BmmContainerType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_PARAMETER_TYPE" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::entity::bmm_type::BmmType::BmmParameterType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_SIGNATURE" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::entity::bmm_type::BmmType::BmmSignature(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::entity::bmm_type::BmmType::BmmSimpleType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_TUPLE_TYPE" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::entity::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_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_PARAMETER_TYPE, BMM_SIGNATURE, BMM_SIMPLE_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_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_PARAMETER_TYPE, BMM_SIGNATURE, BMM_SIMPLE_TYPE, BMM_TUPLE_TYPE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_TYPE",
                            "BMM_CONTAINER_TYPE, BMM_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_PARAMETER_TYPE, BMM_SIGNATURE, BMM_SIMPLE_TYPE, BMM_TUPLE_TYPE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::core::bmm_typed::BmmTyped {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmConstant(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmContainerProperty(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmContainerValue(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmFunction(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmIntervalValue(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmLocal(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmParameter(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmPrimitiveValue(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmResult(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmUnitaryProperty(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::core::bmm_typed::BmmTyped {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_BOOLEAN_VALUE",
            "BMM_CONSTANT",
            "BMM_CONTAINER_PROPERTY",
            "BMM_CONTAINER_VALUE",
            "BMM_FUNCTION",
            "BMM_INDEXED_CONTAINER_PROPERTY",
            "BMM_INDEXED_CONTAINER_VALUE",
            "BMM_INTEGER_VALUE",
            "BMM_INTERVAL_VALUE",
            "BMM_LOCAL",
            "BMM_PARAMETER",
            "BMM_PRIMITIVE_VALUE",
            "BMM_RESULT",
            "BMM_STRING_VALUE",
            "BMM_UNITARY_PROPERTY",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::core::bmm_typed::BmmTyped;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_TYPED` 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::v1_0::bmm::core::bmm_typed::BmmTyped::BmmPrimitiveValue(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_CONSTANT" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmConstant(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmContainerProperty(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_CONTAINER_VALUE" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmContainerValue(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_FUNCTION" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmFunction(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmContainerProperty(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_INDEXED_CONTAINER_VALUE" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmContainerValue(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_INTEGER_VALUE" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmPrimitiveValue(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_INTERVAL_VALUE" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmIntervalValue(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_LOCAL" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmLocal(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_PARAMETER" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmParameter(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_PRIMITIVE_VALUE" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmPrimitiveValue(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_RESULT" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmResult(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_STRING_VALUE" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmPrimitiveValue(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_UNITARY_PROPERTY" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::core::bmm_typed::BmmTyped::BmmUnitaryProperty(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            __other => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unexpected_type(
                                    "BMM_TYPED",
                                    __other,
                                    "BMM_BOOLEAN_VALUE, BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_CONTAINER_VALUE, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_INDEXED_CONTAINER_VALUE, BMM_INTEGER_VALUE, BMM_INTERVAL_VALUE, BMM_LOCAL, BMM_PARAMETER, BMM_PRIMITIVE_VALUE, BMM_RESULT, BMM_STRING_VALUE, BMM_UNITARY_PROPERTY",
                                ),
                            ),
                        }
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_TYPED",
                            &__other,
                            "BMM_BOOLEAN_VALUE, BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_CONTAINER_VALUE, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_INDEXED_CONTAINER_VALUE, BMM_INTEGER_VALUE, BMM_INTERVAL_VALUE, BMM_LOCAL, BMM_PARAMETER, BMM_PRIMITIVE_VALUE, BMM_RESULT, BMM_STRING_VALUE, BMM_UNITARY_PROPERTY",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_TYPED",
                            "BMM_BOOLEAN_VALUE, BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_CONTAINER_VALUE, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_INDEXED_CONTAINER_VALUE, BMM_INTEGER_VALUE, BMM_INTERVAL_VALUE, BMM_LOCAL, BMM_PARAMETER, BMM_PRIMITIVE_VALUE, BMM_RESULT, BMM_STRING_VALUE, BMM_UNITARY_PROPERTY",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature::BmmConstant(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature::BmmContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature::BmmFunction(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature::BmmLocal(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature::BmmParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature::BmmResult(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature::BmmUnitaryProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature
{
    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_RESULT",
            "BMM_UNITARY_PROPERTY",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_TYPED_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::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature::BmmConstant(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_FUNCTION" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature::BmmFunction(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_LOCAL" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature::BmmLocal(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PARAMETER" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature::BmmParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_RESULT" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature::BmmResult(::serde::Deserialize::deserialize(__rest)?)),
"BMM_UNITARY_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_typed_feature::BmmTypedFeature::BmmUnitaryProperty(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_TYPED_FEATURE", __other, "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_PARAMETER, BMM_RESULT, BMM_UNITARY_PROPERTY")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_TYPED_FEATURE",
                            &__other,
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_PARAMETER, BMM_RESULT, BMM_UNITARY_PROPERTY",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_TYPED_FEATURE",
                            "BMM_CONSTANT, BMM_CONTAINER_PROPERTY, BMM_FUNCTION, BMM_INDEXED_CONTAINER_PROPERTY, BMM_LOCAL, BMM_PARAMETER, BMM_RESULT, BMM_UNITARY_PROPERTY",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::core::feature::bmm_unitary_property::BmmUnitaryProperty
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 5usize;
        if self.is_nullable.is_some() {
            __n += 1;
        }
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.extensions.is_some() {
            __n += 1;
        }
        if self.is_synthesised_generic.is_some() {
            __n += 1;
        }
        if self.visibility.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, "type", &self.r#type)?;
        if let Some(__v) = &self.is_nullable {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?;
        }
        ::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)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "scope", &self.scope)?;
        if let Some(__v) = &self.extensions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "extensions", __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.visibility {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "visibility", __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::v1_0::bmm::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",
            "scope",
            "type",
            "visibility",
        ];
        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),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            "is_nullable" => ::core::result::Result::Ok(__Field::__F1),
                            "name" => ::core::result::Result::Ok(__Field::__F2),
                            "documentation" => ::core::result::Result::Ok(__Field::__F3),
                            "scope" => ::core::result::Result::Ok(__Field::__F4),
                            "extensions" => ::core::result::Result::Ok(__Field::__F5),
                            "is_synthesised_generic" => ::core::result::Result::Ok(__Field::__F6),
                            "visibility" => ::core::result::Result::Ok(__Field::__F7),
                            "feature_extensions" => ::core::result::Result::Ok(__Field::__F8),
                            "group" => ::core::result::Result::Ok(__Field::__F9),
                            "is_im_runtime" => ::core::result::Result::Ok(__Field::__F10),
                            "is_im_infrastructure" => ::core::result::Result::Ok(__Field::__F11),
                            "is_composition" => ::core::result::Result::Ok(__Field::__F12),
                            _ => ::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::v1_0::bmm::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<::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<::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("BMM_UNITARY_PROPERTY"),
                            )?;
                        }
                        __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("is_nullable"),
                                );
                            }
                            __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("documentation"),
                                );
                            }
                            __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("scope"),
                                );
                            }
                            __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("extensions"),
                                );
                            }
                            __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_synthesised_generic"),
                                );
                            }
                            __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("visibility"),
                                );
                            }
                            __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("feature_extensions"),
                                );
                            }
                            __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("group"),
                                );
                            }
                            __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_im_runtime"),
                                );
                            }
                            __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("is_im_infrastructure"),
                                );
                            }
                            __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("is_composition"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::core::feature::bmm_unitary_property::BmmUnitaryProperty {
                        r#type: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        is_nullable: __s1.flatten(),
                        name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        documentation: __s3.flatten(),
                        scope: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("scope"))?,
                        extensions: __s5.flatten(),
                        is_synthesised_generic: __s6.flatten(),
                        visibility: __s7.flatten(),
                        feature_extensions: __s8,
                        group: __s9
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("group"))?,
                        is_im_runtime: __s10.flatten(),
                        is_im_infrastructure: __s11.flatten(),
                        is_composition: __s12.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_UNITARY_PROPERTY",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::entity::bmm_unitary_type::BmmUnitaryType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_GENERIC_TYPE",
            "BMM_PARAMETER_TYPE",
            "BMM_SIGNATURE",
            "BMM_SIMPLE_TYPE",
            "BMM_TUPLE_TYPE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::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_GENERIC_TYPE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::bmm_unitary_type::BmmUnitaryType::BmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PARAMETER_TYPE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::bmm_unitary_type::BmmUnitaryType::BmmParameterType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIGNATURE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSimpleType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_TUPLE_TYPE" => ::core::result::Result::Ok(crate::v1_0::bmm::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_GENERIC_TYPE, BMM_PARAMETER_TYPE, BMM_SIGNATURE, BMM_SIMPLE_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_GENERIC_TYPE, BMM_PARAMETER_TYPE, BMM_SIGNATURE, BMM_SIMPLE_TYPE, BMM_TUPLE_TYPE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_UNITARY_TYPE",
                            "BMM_GENERIC_TYPE, BMM_PARAMETER_TYPE, BMM_SIGNATURE, BMM_SIMPLE_TYPE, BMM_TUPLE_TYPE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::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::v1_0::bmm::core::literal_value::bmm_unitary_value::BmmUnitaryValue::BmmPrimitiveValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::core::literal_value::bmm_unitary_value::BmmUnitaryValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INTEGER_VALUE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::literal_value::bmm_unitary_value::BmmUnitaryValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PRIMITIVE_VALUE" => ::core::result::Result::Ok(crate::v1_0::bmm::core::literal_value::bmm_unitary_value::BmmUnitaryValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STRING_VALUE" => ::core::result::Result::Ok(crate::v1_0::bmm::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::v1_0::bmm::core::entity::range_constrained::bmm_value_set_spec::BmmValueSetSpec
{
    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_VALUE_SET_SPEC", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_VALUE_SET_SPEC")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "resource_id",
            &self.resource_id,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "value_set_id",
            &self.value_set_id,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::entity::range_constrained::bmm_value_set_spec::BmmValueSetSpec
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["resource_id", "value_set_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),
                            "resource_id" => ::core::result::Result::Ok(__Field::__F0),
                            "value_set_id" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_VALUE_SET_SPEC",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::core::entity::range_constrained::bmm_value_set_spec::BmmValueSetSpec;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_VALUE_SET_SPEC` 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_VALUE_SET_SPEC"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("resource_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("value_set_id"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_0::bmm::core::entity::range_constrained::bmm_value_set_spec::BmmValueSetSpec {
resource_id: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("resource_id"))?,
value_set_id: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("value_set_id"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_VALUE_SET_SPEC",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::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"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::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::v1_0::bmm::core::feature::bmm_variable::BmmVariable::BmmLocal(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PARAMETER" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_variable::BmmVariable::BmmParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_RESULT" => ::core::result::Result::Ok(crate::v1_0::bmm::core::feature::bmm_variable::BmmVariable::BmmResult(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_VARIABLE", __other, "BMM_LOCAL, BMM_PARAMETER, BMM_RESULT")),
}
                    }
                    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",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_VARIABLE",
                            "BMM_LOCAL, BMM_PARAMETER, BMM_RESULT",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::core::feature::bmm_visibility::BmmVisibility {
    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_VISIBILITY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_VISIBILITY")?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::core::feature::bmm_visibility::BmmVisibility
{
    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_VISIBILITY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::core::feature::bmm_visibility::BmmVisibility;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_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;
                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_VISIBILITY"),
                            )?;
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::core::feature::bmm_visibility::BmmVisibility {},
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_VISIBILITY",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::expression::el_agent::ElAgent::ElFunctionAgent(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::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::v1_0::bmm::expression::el_agent_call::ElAgentCall {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_0::bmm::expression::el_agent_call::ElAgentCall::BmmProcedureCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_agent_call::ElAgentCall::ElFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::expression::el_agent_call::ElAgentCall::BmmProcedureCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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, "definition", &self.definition)?;
        ::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_0::bmm::expression::el_binary_operator::ElBinaryOperator
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "definition",
            "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),
                            "definition" => ::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::v1_0::bmm::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("definition"),
                                );
                            }
                            __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_0::bmm::expression::el_binary_operator::ElBinaryOperator {
                        precedence_overridden: __s0.flatten(),
                        symbol: __s1.flatten(),
                        definition: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("definition"))?,
                        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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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 ::serde::Serialize for crate::v1_0::bmm::expression::el_case::ElCase {
    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> ::serde::Deserialize<'de> for crate::v1_0::bmm::expression::el_case::ElCase {
    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;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::expression::el_case::ElCase;
            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::v1_0::bmm::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)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::expression::el_case_table::ElCaseTable {
    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, "else", &self.r#else)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "items", &self.items)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "input", &self.input)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::expression::el_case_table::ElCaseTable {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["else", "input", "items"];
        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),
                            "else" => ::core::result::Result::Ok(__Field::__F0),
                            "items" => ::core::result::Result::Ok(__Field::__F1),
                            "input" => ::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;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::expression::el_case_table::ElCaseTable;
            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("else"),
                                );
                            }
                            __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)?);
                        }
                        __Field::__F2 => {
                            if __s2.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("input"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::expression::el_case_table::ElCaseTable {
                        r#else: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("else"))?,
                        items: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("items"))?,
                        input: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("input"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_CASE_TABLE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::bmm::expression::el_conditional_expression::ElConditionalExpression
{
    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> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::expression::el_conditional_expression::ElConditionalExpression
{
    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;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_0::bmm::expression::el_conditional_expression::ElConditionalExpression;
            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::v1_0::bmm::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,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::expression::el_condition_chain::ElConditionChain {
    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, "else", &self.r#else)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "items", &self.items)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::expression::el_condition_chain::ElConditionChain
{
    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),
                            "else" => ::core::result::Result::Ok(__Field::__F0),
                            "items" => ::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;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::expression::el_condition_chain::ElConditionChain;
            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("else"),
                                );
                            }
                            __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_0::bmm::expression::el_condition_chain::ElConditionChain {
                        r#else: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("else"))?,
                        items: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("items"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_CONDITION_CHAIN",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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 ::serde::Serialize for crate::v1_0::bmm::expression::el_decision_branch::ElDecisionBranch {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_0::bmm::expression::el_decision_branch::ElDecisionBranch::ElCase(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm::expression::el_decision_branch::ElDecisionBranch::ElConditionalExpression(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::expression::el_decision_branch::ElDecisionBranch
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["EL_CASE", "EL_CONDITIONAL_EXPRESSION"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::expression::el_decision_branch::ElDecisionBranch;
            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::v1_0::bmm::expression::el_decision_branch::ElDecisionBranch::ElCase(::serde::Deserialize::deserialize(__rest)?)),
"EL_CONDITIONAL_EXPRESSION" => ::core::result::Result::Ok(crate::v1_0::bmm::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)
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::expression::el_decision_table::ElDecisionTable
{
    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;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::expression::el_decision_table::ElDecisionTable;
            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::v1_0::bmm::expression::el_decision_table::ElDecisionTable::ElCaseTable(::serde::Deserialize::deserialize(__rest)?)),
"EL_CONDITION_CHAIN" => ::core::result::Result::Ok(crate::v1_0::bmm::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)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::expression::el_expression::ElExpression {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_0::bmm::expression::el_expression::ElExpression::ElAttached(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_expression::ElExpression::ElBinaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_expression::ElExpression::ElBooleanExpression(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_expression::ElExpression::ElCaseTable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_expression::ElExpression::ElConditionChain(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_expression::ElExpression::ElDefined(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_expression::ElExpression::ElFunctionAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_expression::ElExpression::ElFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_expression::ElExpression::ElInstantiableRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_expression::ElExpression::ElLiteral(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_expression::ElExpression::ElProcedureAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_expression::ElExpression::ElSelfRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_expression::ElExpression::ElTuple(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_expression::ElExpression::ElTypeRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_expression::ElExpression::ElUnaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::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_INSTANTIABLE_REF",
            "EL_LITERAL",
            "EL_PROCEDURE_AGENT",
            "EL_SELF_REF",
            "EL_TUPLE",
            "EL_TYPE_REF",
            "EL_UNARY_OPERATOR",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::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::v1_0::bmm::expression::el_expression::ElExpression::ElAttached(::serde::Deserialize::deserialize(__rest)?)),
"EL_BINARY_OPERATOR" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_expression::ElExpression::ElBinaryOperator(::serde::Deserialize::deserialize(__rest)?)),
"EL_BOOLEAN_EXPRESSION" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_expression::ElExpression::ElBooleanExpression(::serde::Deserialize::deserialize(__rest)?)),
"EL_CASE_TABLE" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_expression::ElExpression::ElCaseTable(::serde::Deserialize::deserialize(__rest)?)),
"EL_CONDITION_CHAIN" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_expression::ElExpression::ElConditionChain(::serde::Deserialize::deserialize(__rest)?)),
"EL_DEFINED" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_expression::ElExpression::ElDefined(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_AGENT" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_expression::ElExpression::ElFunctionAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_expression::ElExpression::ElFunctionCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_INSTANTIABLE_REF" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_expression::ElExpression::ElInstantiableRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_LITERAL" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_expression::ElExpression::ElLiteral(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_expression::ElExpression::ElProcedureAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_SELF_REF" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_expression::ElExpression::ElSelfRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_TUPLE" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_expression::ElExpression::ElTuple(::serde::Deserialize::deserialize(__rest)?)),
"EL_TYPE_REF" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_expression::ElExpression::ElTypeRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_UNARY_OPERATOR" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_expression::ElExpression::ElUnaryOperator(::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_INSTANTIABLE_REF, EL_LITERAL, EL_PROCEDURE_AGENT, EL_SELF_REF, EL_TUPLE, EL_TYPE_REF, EL_UNARY_OPERATOR")),
}
                    }
                    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_INSTANTIABLE_REF, EL_LITERAL, EL_PROCEDURE_AGENT, EL_SELF_REF, EL_TUPLE, EL_TYPE_REF, EL_UNARY_OPERATOR",
                        ))
                    }
                    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_INSTANTIABLE_REF, EL_LITERAL, EL_PROCEDURE_AGENT, EL_SELF_REF, EL_TUPLE, EL_TYPE_REF, EL_UNARY_OPERATOR",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::expression::el_function_agent::ElFunctionAgent {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.scope.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")?;
        if let Some(__v) = &self.scope {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "scope", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        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::v1_0::bmm::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", "name", "open_args", "scope"];
        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),
                            "scope" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "closed_args" => ::core::result::Result::Ok(__Field::__F2),
                            "open_args" => ::core::result::Result::Ok(__Field::__F3),
                            "definition" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::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::v1_0::bmm::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<_> = 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_FUNCTION_AGENT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("scope"),
                                );
                            }
                            __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("closed_args"),
                                );
                            }
                            __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("open_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("definition"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::expression::el_function_agent::ElFunctionAgent {
                        scope: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        closed_args: __s2.flatten(),
                        open_args: __s3,
                        definition: __s4.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_FUNCTION_AGENT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::expression::el_function_call::ElFunctionCall {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.scope.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")?;
        if let Some(__v) = &self.scope {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "scope", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "agent", &self.agent)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::expression::el_function_call::ElFunctionCall
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["agent", "scope"];
        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),
                            "scope" => ::core::result::Result::Ok(__Field::__F0),
                            "agent" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::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::v1_0::bmm::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;
                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("scope"),
                                );
                            }
                            __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("agent"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::expression::el_function_call::ElFunctionCall {
                        scope: __s0.flatten(),
                        agent: __s1
                            .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::v1_0::bmm::expression::el_instance_ref::ElInstanceRef {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_0::bmm::expression::el_instance_ref::ElInstanceRef::ElFunctionAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_instance_ref::ElInstanceRef::ElFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_instance_ref::ElInstanceRef::ElInstantiableRef(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_0::bmm::expression::el_instance_ref::ElInstanceRef::ElLiteral(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_instance_ref::ElInstanceRef::ElProcedureAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_instance_ref::ElInstanceRef::ElSelfRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_instance_ref::ElInstanceRef::ElTuple(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_instance_ref::ElInstanceRef::ElTypeRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::expression::el_instance_ref::ElInstanceRef
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "EL_FUNCTION_AGENT",
            "EL_FUNCTION_CALL",
            "EL_INSTANTIABLE_REF",
            "EL_LITERAL",
            "EL_PROCEDURE_AGENT",
            "EL_SELF_REF",
            "EL_TUPLE",
            "EL_TYPE_REF",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::expression::el_instance_ref::ElInstanceRef;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_INSTANCE_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::v1_0::bmm::expression::el_instance_ref::ElInstanceRef::ElFunctionAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_instance_ref::ElInstanceRef::ElFunctionCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_INSTANTIABLE_REF" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_instance_ref::ElInstanceRef::ElInstantiableRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_LITERAL" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_instance_ref::ElInstanceRef::ElLiteral(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_instance_ref::ElInstanceRef::ElProcedureAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_SELF_REF" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_instance_ref::ElInstanceRef::ElSelfRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_TUPLE" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_instance_ref::ElInstanceRef::ElTuple(::serde::Deserialize::deserialize(__rest)?)),
"EL_TYPE_REF" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_instance_ref::ElInstanceRef::ElTypeRef(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EL_INSTANCE_REF", __other, "EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_INSTANTIABLE_REF, EL_LITERAL, EL_PROCEDURE_AGENT, EL_SELF_REF, EL_TUPLE, EL_TYPE_REF")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_INSTANCE_REF",
                            &__other,
                            "EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_INSTANTIABLE_REF, EL_LITERAL, EL_PROCEDURE_AGENT, EL_SELF_REF, EL_TUPLE, EL_TYPE_REF",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_INSTANCE_REF",
                            "EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_INSTANTIABLE_REF, EL_LITERAL, EL_PROCEDURE_AGENT, EL_SELF_REF, EL_TUPLE, EL_TYPE_REF",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl<T: ::serde::Serialize> ::serde::Serialize
    for crate::v1_0::bmm::expression::el_instantiable_ref::ElInstantiableRef<T>
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.scope.is_some() {
            __n += 1;
        }
        if self.definition.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "EL_INSTANTIABLE_REF", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_INSTANTIABLE_REF")?;
        if let Some(__v) = &self.scope {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "scope", __v)?;
        }
        if let Some(__v) = &self.definition {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "definition", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de, T: ::serde::de::DeserializeOwned> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::expression::el_instantiable_ref::ElInstantiableRef<T>
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["definition", "scope"];
        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),
                            "scope" => ::core::result::Result::Ok(__Field::__F0),
                            "definition" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_INSTANTIABLE_REF",
                                    __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::v1_0::bmm::expression::el_instantiable_ref::ElInstantiableRef<T>;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_INSTANTIABLE_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("EL_INSTANTIABLE_REF"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("scope"),
                                );
                            }
                            __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_0::bmm::expression::el_instantiable_ref::ElInstantiableRef {
                        scope: __s0.flatten(),
                        definition: __s1.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_INSTANTIABLE_REF",
            __FIELDS,
            __Visitor(::core::marker::PhantomData),
        )
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::expression::el_operator::ElOperator {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_0::bmm::expression::el_operator::ElOperator::ElBinaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_operator::ElOperator::ElUnaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::expression::el_operator::ElOperator::ElBinaryOperator(::serde::Deserialize::deserialize(__rest)?)),
"EL_UNARY_OPERATOR" => ::core::result::Result::Ok(crate::v1_0::bmm::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::v1_0::bmm::expression::el_predicate::ElPredicate {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_0::bmm::expression::el_predicate::ElPredicate::ElAttached(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_predicate::ElPredicate::ElDefined(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::expression::el_predicate::ElPredicate::ElAttached(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EL_DEFINED" => ::core::result::Result::Ok(
                                crate::v1_0::bmm::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::v1_0::bmm::expression::el_procedure_agent::ElProcedureAgent {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.scope.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")?;
        if let Some(__v) = &self.scope {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "scope", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        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::v1_0::bmm::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", "name", "open_args", "scope"];
        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),
                            "scope" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "closed_args" => ::core::result::Result::Ok(__Field::__F2),
                            "open_args" => ::core::result::Result::Ok(__Field::__F3),
                            "definition" => ::core::result::Result::Ok(__Field::__F4),
                            _ => ::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::v1_0::bmm::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<_> = 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_PROCEDURE_AGENT"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("scope"),
                                );
                            }
                            __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("closed_args"),
                                );
                            }
                            __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("open_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("definition"),
                                );
                            }
                            __s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm::expression::el_procedure_agent::ElProcedureAgent {
                        scope: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        closed_args: __s2.flatten(),
                        open_args: __s3,
                        definition: __s4.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_PROCEDURE_AGENT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::expression::el_scoped_ref::ElScopedRef {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_0::bmm::expression::el_scoped_ref::ElScopedRef::ElFunctionAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_scoped_ref::ElScopedRef::ElFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_scoped_ref::ElScopedRef::ElInstantiableRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_scoped_ref::ElScopedRef::ElProcedureAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::expression::el_scoped_ref::ElScopedRef {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "EL_FUNCTION_AGENT",
            "EL_FUNCTION_CALL",
            "EL_INSTANTIABLE_REF",
            "EL_PROCEDURE_AGENT",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::expression::el_scoped_ref::ElScopedRef;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_SCOPED_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::v1_0::bmm::expression::el_scoped_ref::ElScopedRef::ElFunctionAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_scoped_ref::ElScopedRef::ElFunctionCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_INSTANTIABLE_REF" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_scoped_ref::ElScopedRef::ElInstantiableRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_scoped_ref::ElScopedRef::ElProcedureAgent(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EL_SCOPED_REF", __other, "EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_INSTANTIABLE_REF, EL_PROCEDURE_AGENT")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_SCOPED_REF",
                            &__other,
                            "EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_INSTANTIABLE_REF, EL_PROCEDURE_AGENT",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_SCOPED_REF",
                            "EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_INSTANTIABLE_REF, EL_PROCEDURE_AGENT",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::expression::el_self_ref::ElSelfRef {
    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_SELF_REF", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_SELF_REF")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::expression::el_self_ref::ElSelfRef {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["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),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EL_SELF_REF",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::expression::el_self_ref::ElSelfRef;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_SELF_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("EL_SELF_REF"),
                            )?;
                        }
                        __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)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_self_ref::ElSelfRef {
                    r#type: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_SELF_REF",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::expression::el_simple::ElSimple {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_0::bmm::expression::el_simple::ElSimple::ElAttached(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_simple::ElSimple::ElBinaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_simple::ElSimple::ElDefined(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_simple::ElSimple::ElFunctionAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_simple::ElSimple::ElFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_simple::ElSimple::ElInstantiableRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_simple::ElSimple::ElLiteral(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_simple::ElSimple::ElProcedureAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_simple::ElSimple::ElSelfRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_simple::ElSimple::ElTuple(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_simple::ElSimple::ElTypeRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_simple::ElSimple::ElUnaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::expression::el_simple::ElSimple {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "EL_ATTACHED",
            "EL_BINARY_OPERATOR",
            "EL_DEFINED",
            "EL_FUNCTION_AGENT",
            "EL_FUNCTION_CALL",
            "EL_INSTANTIABLE_REF",
            "EL_LITERAL",
            "EL_PROCEDURE_AGENT",
            "EL_SELF_REF",
            "EL_TUPLE",
            "EL_TYPE_REF",
            "EL_UNARY_OPERATOR",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::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::v1_0::bmm::expression::el_simple::ElSimple::ElAttached(::serde::Deserialize::deserialize(__rest)?)),
"EL_BINARY_OPERATOR" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_simple::ElSimple::ElBinaryOperator(::serde::Deserialize::deserialize(__rest)?)),
"EL_DEFINED" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_simple::ElSimple::ElDefined(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_AGENT" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_simple::ElSimple::ElFunctionAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_simple::ElSimple::ElFunctionCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_INSTANTIABLE_REF" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_simple::ElSimple::ElInstantiableRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_LITERAL" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_simple::ElSimple::ElLiteral(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_simple::ElSimple::ElProcedureAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_SELF_REF" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_simple::ElSimple::ElSelfRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_TUPLE" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_simple::ElSimple::ElTuple(::serde::Deserialize::deserialize(__rest)?)),
"EL_TYPE_REF" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_simple::ElSimple::ElTypeRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_UNARY_OPERATOR" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_simple::ElSimple::ElUnaryOperator(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EL_SIMPLE", __other, "EL_ATTACHED, EL_BINARY_OPERATOR, EL_DEFINED, EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_INSTANTIABLE_REF, EL_LITERAL, EL_PROCEDURE_AGENT, EL_SELF_REF, EL_TUPLE, EL_TYPE_REF, EL_UNARY_OPERATOR")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_SIMPLE",
                            &__other,
                            "EL_ATTACHED, EL_BINARY_OPERATOR, EL_DEFINED, EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_INSTANTIABLE_REF, EL_LITERAL, EL_PROCEDURE_AGENT, EL_SELF_REF, EL_TUPLE, EL_TYPE_REF, EL_UNARY_OPERATOR",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_SIMPLE",
                            "EL_ATTACHED, EL_BINARY_OPERATOR, EL_DEFINED, EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_INSTANTIABLE_REF, EL_LITERAL, EL_PROCEDURE_AGENT, EL_SELF_REF, EL_TUPLE, EL_TYPE_REF, EL_UNARY_OPERATOR",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::expression::el_terminal::ElTerminal {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElAttached(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElDefined(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElFunctionAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElInstantiableRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElLiteral(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElProcedureAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElSelfRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElTuple(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElTypeRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::expression::el_terminal::ElTerminal {
    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_INSTANTIABLE_REF",
            "EL_LITERAL",
            "EL_PROCEDURE_AGENT",
            "EL_SELF_REF",
            "EL_TUPLE",
            "EL_TYPE_REF",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::bmm::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::v1_0::bmm::expression::el_terminal::ElTerminal::ElAttached(::serde::Deserialize::deserialize(__rest)?)),
"EL_DEFINED" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElDefined(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_AGENT" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElFunctionAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElFunctionCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_INSTANTIABLE_REF" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElInstantiableRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_LITERAL" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElLiteral(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElProcedureAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_SELF_REF" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElSelfRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_TUPLE" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElTuple(::serde::Deserialize::deserialize(__rest)?)),
"EL_TYPE_REF" => ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_terminal::ElTerminal::ElTypeRef(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EL_TERMINAL", __other, "EL_ATTACHED, EL_DEFINED, EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_INSTANTIABLE_REF, EL_LITERAL, EL_PROCEDURE_AGENT, EL_SELF_REF, EL_TUPLE, EL_TYPE_REF")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_TERMINAL",
                            &__other,
                            "EL_ATTACHED, EL_DEFINED, EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_INSTANTIABLE_REF, EL_LITERAL, EL_PROCEDURE_AGENT, EL_SELF_REF, EL_TUPLE, EL_TYPE_REF",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_TERMINAL",
                            "EL_ATTACHED, EL_DEFINED, EL_FUNCTION_AGENT, EL_FUNCTION_CALL, EL_INSTANTIABLE_REF, EL_LITERAL, EL_PROCEDURE_AGENT, EL_SELF_REF, EL_TUPLE, EL_TYPE_REF",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::bmm::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::v1_0::obsolete_elom::types::el_type_def::ElTypeDef {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefBoolean(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefDate(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefDateTime(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefDuration(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefInteger(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefObjectRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefReal(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefString(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefTerminologyCode(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefTime(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefUri(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "TYPE_DEF_BOOLEAN",
            "TYPE_DEF_DATE",
            "TYPE_DEF_DATE_TIME",
            "TYPE_DEF_DURATION",
            "TYPE_DEF_INTEGER",
            "TYPE_DEF_OBJECT_REF",
            "TYPE_DEF_REAL",
            "TYPE_DEF_STRING",
            "TYPE_DEF_TERMINOLOGY_CODE",
            "TYPE_DEF_TIME",
            "TYPE_DEF_URI",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EL_TYPE_DEF` 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 {
"TYPE_DEF_BOOLEAN" => ::core::result::Result::Ok(crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefBoolean(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_DATE" => ::core::result::Result::Ok(crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefDate(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_DATE_TIME" => ::core::result::Result::Ok(crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefDateTime(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_DURATION" => ::core::result::Result::Ok(crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefDuration(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_INTEGER" => ::core::result::Result::Ok(crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefInteger(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_OBJECT_REF" => ::core::result::Result::Ok(crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefObjectRef(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_REAL" => ::core::result::Result::Ok(crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefReal(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_STRING" => ::core::result::Result::Ok(crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefString(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_TERMINOLOGY_CODE" => ::core::result::Result::Ok(crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefTerminologyCode(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_TIME" => ::core::result::Result::Ok(crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefTime(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_URI" => ::core::result::Result::Ok(crate::v1_0::obsolete_elom::types::el_type_def::ElTypeDef::TypeDefUri(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EL_TYPE_DEF", __other, "TYPE_DEF_BOOLEAN, TYPE_DEF_DATE, TYPE_DEF_DATE_TIME, TYPE_DEF_DURATION, TYPE_DEF_INTEGER, TYPE_DEF_OBJECT_REF, TYPE_DEF_REAL, TYPE_DEF_STRING, TYPE_DEF_TERMINOLOGY_CODE, TYPE_DEF_TIME, TYPE_DEF_URI")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EL_TYPE_DEF",
                            &__other,
                            "TYPE_DEF_BOOLEAN, TYPE_DEF_DATE, TYPE_DEF_DATE_TIME, TYPE_DEF_DURATION, TYPE_DEF_INTEGER, TYPE_DEF_OBJECT_REF, TYPE_DEF_REAL, TYPE_DEF_STRING, TYPE_DEF_TERMINOLOGY_CODE, TYPE_DEF_TIME, TYPE_DEF_URI",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EL_TYPE_DEF",
                            "TYPE_DEF_BOOLEAN, TYPE_DEF_DATE, TYPE_DEF_DATE_TIME, TYPE_DEF_DURATION, TYPE_DEF_INTEGER, TYPE_DEF_OBJECT_REF, TYPE_DEF_REAL, TYPE_DEF_STRING, TYPE_DEF_TERMINOLOGY_CODE, TYPE_DEF_TIME, TYPE_DEF_URI",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::expression::el_type_ref::ElTypeRef {
    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_TYPE_REF", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EL_TYPE_REF")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::bmm::expression::el_type_ref::ElTypeRef {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["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),
                            "type" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::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::v1_0::bmm::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;
                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("type"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_0::bmm::expression::el_type_ref::ElTypeRef {
                    r#type: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EL_TYPE_REF",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::bmm::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, "definition", &self.definition)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "operand", &self.operand)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::bmm::expression::el_unary_operator::ElUnaryOperator
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["definition", "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),
                            "definition" => ::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::v1_0::bmm::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("definition"),
                                );
                            }
                            __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_0::bmm::expression::el_unary_operator::ElUnaryOperator {
                        precedence_overridden: __s0.flatten(),
                        symbol: __s1.flatten(),
                        definition: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("definition"))?,
                        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::v1_0::obsolete_elom::extension::function_def_example::FunctionDefExample
{
    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, "FUNCTION_DEF_EXAMPLE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "FUNCTION_DEF_EXAMPLE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "evaluation_agent",
            &self.evaluation_agent,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "identifier", &self.identifier)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::extension::function_def_example::FunctionDefExample
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["evaluation_agent", "identifier"];
        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),
                            "evaluation_agent" => ::core::result::Result::Ok(__Field::__F0),
                            "identifier" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "FUNCTION_DEF_EXAMPLE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_0::obsolete_elom::extension::function_def_example::FunctionDefExample;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `FUNCTION_DEF_EXAMPLE` 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("FUNCTION_DEF_EXAMPLE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("evaluation_agent"),
                                );
                            }
                            __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("identifier"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_0::obsolete_elom::extension::function_def_example::FunctionDefExample {
evaluation_agent: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("evaluation_agent"))?,
identifier: __s1.flatten().unwrap_or(::std::string::String::from("funny")),
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "FUNCTION_DEF_EXAMPLE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::obsolete_elom::extension::function_def_external::FunctionDefExternal
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_0::obsolete_elom::extension::function_def_external::FunctionDefExternal::FunctionDefExample(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::extension::function_def_external::FunctionDefExternal
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["FUNCTION_DEF_EXAMPLE"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_0::obsolete_elom::extension::function_def_external::FunctionDefExternal;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `FUNCTION_DEF_EXTERNAL` 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 {
"FUNCTION_DEF_EXAMPLE" => ::core::result::Result::Ok(crate::v1_0::obsolete_elom::extension::function_def_external::FunctionDefExternal::FunctionDefExample(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("FUNCTION_DEF_EXTERNAL", __other, "FUNCTION_DEF_EXAMPLE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "FUNCTION_DEF_EXTERNAL",
                            &__other,
                            "FUNCTION_DEF_EXAMPLE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "FUNCTION_DEF_EXTERNAL",
                            "FUNCTION_DEF_EXAMPLE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_0::obsolete_elom::extension::operator_def_external::OperatorDefExternal
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_0::obsolete_elom::extension::operator_def_external::OperatorDefExternal::OpDefAnd(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::obsolete_elom::extension::operator_def_external::OperatorDefExternal::OpDefExample(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::obsolete_elom::extension::operator_def_external::OperatorDefExternal::OpDefExists(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::extension::operator_def_external::OperatorDefExternal
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["OP_DEF_AND", "OP_DEF_EXAMPLE", "OP_DEF_EXISTS"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_0::obsolete_elom::extension::operator_def_external::OperatorDefExternal;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `OPERATOR_DEF_EXTERNAL` 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 {
"OP_DEF_AND" => ::core::result::Result::Ok(crate::v1_0::obsolete_elom::extension::operator_def_external::OperatorDefExternal::OpDefAnd(::serde::Deserialize::deserialize(__rest)?)),
"OP_DEF_EXAMPLE" => ::core::result::Result::Ok(crate::v1_0::obsolete_elom::extension::operator_def_external::OperatorDefExternal::OpDefExample(::serde::Deserialize::deserialize(__rest)?)),
"OP_DEF_EXISTS" => ::core::result::Result::Ok(crate::v1_0::obsolete_elom::extension::operator_def_external::OperatorDefExternal::OpDefExists(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("OPERATOR_DEF_EXTERNAL", __other, "OP_DEF_AND, OP_DEF_EXAMPLE, OP_DEF_EXISTS")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "OPERATOR_DEF_EXTERNAL",
                            &__other,
                            "OP_DEF_AND, OP_DEF_EXAMPLE, OP_DEF_EXISTS",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "OPERATOR_DEF_EXTERNAL",
                            "OP_DEF_AND, OP_DEF_EXAMPLE, OP_DEF_EXISTS",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::obsolete_elom::extension::op_def_and::OpDefAnd {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.symbols.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "OP_DEF_AND", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "OP_DEF_AND")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "evaluation_agent",
            &self.evaluation_agent,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "identifier", &self.identifier)?;
        if let Some(__v) = &self.symbols
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "symbols", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::extension::op_def_and::OpDefAnd
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["evaluation_agent", "identifier", "symbols"];
        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),
                            "evaluation_agent" => ::core::result::Result::Ok(__Field::__F0),
                            "identifier" => ::core::result::Result::Ok(__Field::__F1),
                            "symbols" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "OP_DEF_AND",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::obsolete_elom::extension::op_def_and::OpDefAnd;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `OP_DEF_AND` 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("OP_DEF_AND"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("evaluation_agent"),
                                );
                            }
                            __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("identifier"),
                                );
                            }
                            __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("symbols"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::obsolete_elom::extension::op_def_and::OpDefAnd {
                        evaluation_agent: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("evaluation_agent"))?,
                        identifier: __s1.flatten().unwrap_or(::std::string::String::from("and")),
                        symbols: __s2,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "OP_DEF_AND", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::obsolete_elom::extension::op_def_example::OpDefExample {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.symbols.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "OP_DEF_EXAMPLE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "OP_DEF_EXAMPLE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "evaluation_agent",
            &self.evaluation_agent,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "identifier", &self.identifier)?;
        if let Some(__v) = &self.symbols
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "symbols", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::extension::op_def_example::OpDefExample
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["evaluation_agent", "identifier", "symbols"];
        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),
                            "evaluation_agent" => ::core::result::Result::Ok(__Field::__F0),
                            "identifier" => ::core::result::Result::Ok(__Field::__F1),
                            "symbols" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "OP_DEF_EXAMPLE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::obsolete_elom::extension::op_def_example::OpDefExample;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `OP_DEF_EXAMPLE` 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("OP_DEF_EXAMPLE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("evaluation_agent"),
                                );
                            }
                            __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("identifier"),
                                );
                            }
                            __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("symbols"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::obsolete_elom::extension::op_def_example::OpDefExample {
                        evaluation_agent: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("evaluation_agent"))?,
                        identifier: __s1.flatten().unwrap_or(::std::string::String::from("xxx")),
                        symbols: __s2,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "OP_DEF_EXAMPLE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::obsolete_elom::extension::op_def_exists::OpDefExists {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.symbols.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "OP_DEF_EXISTS", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "OP_DEF_EXISTS")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "evaluation_agent",
            &self.evaluation_agent,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "identifier", &self.identifier)?;
        if let Some(__v) = &self.symbols
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "symbols", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::extension::op_def_exists::OpDefExists
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["evaluation_agent", "identifier", "symbols"];
        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),
                            "evaluation_agent" => ::core::result::Result::Ok(__Field::__F0),
                            "identifier" => ::core::result::Result::Ok(__Field::__F1),
                            "symbols" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "OP_DEF_EXISTS",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::obsolete_elom::extension::op_def_exists::OpDefExists;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `OP_DEF_EXISTS` 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("OP_DEF_EXISTS"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("evaluation_agent"),
                                );
                            }
                            __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("identifier"),
                                );
                            }
                            __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("symbols"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::obsolete_elom::extension::op_def_exists::OpDefExists {
                        evaluation_agent: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("evaluation_agent"))?,
                        identifier: __s1
                            .flatten()
                            .unwrap_or(::std::string::String::from("exists")),
                        symbols: __s2,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "OP_DEF_EXISTS",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::obsolete_elom::extension::op_def_plus::OpDefPlus {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.symbols.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "OP_DEF_PLUS", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "OP_DEF_PLUS")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        if let Some(__v) = &self.symbols
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "symbols", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::extension::op_def_plus::OpDefPlus
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["name", "symbols"];
        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),
                            "symbols" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "OP_DEF_PLUS",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::obsolete_elom::extension::op_def_plus::OpDefPlus;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `OP_DEF_PLUS` 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("OP_DEF_PLUS"),
                            )?;
                        }
                        __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("symbols"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::obsolete_elom::extension::op_def_plus::OpDefPlus {
                        name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("plus")),
                        symbols: __s1,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "OP_DEF_PLUS",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::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::v1_0::bmm_persistence::p_bmm_base_type::PBmmBaseType::PBmmGenericType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm_persistence::p_bmm_base_type::PBmmBaseType::PBmmOpenType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_0::bmm_persistence::p_bmm_base_type::PBmmBaseType::PBmmSimpleType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::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::v1_0::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::v1_0::bmm_persistence::p_bmm_base_type::PBmmBaseType::PBmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_OPEN_TYPE" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_base_type::PBmmBaseType::PBmmOpenType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v1_0::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::v1_0::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.properties.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.properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "properties", __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::v1_0::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",
            "documentation",
            "generic_parameter_defs",
            "is_abstract",
            "is_override",
            "name",
            "properties",
            "source_schema_id",
            "uid",
        ];
        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),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F2),
                            "properties" => ::core::result::Result::Ok(__Field::__F3),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F4),
                            "is_override" => ::core::result::Result::Ok(__Field::__F5),
                            "generic_parameter_defs" => ::core::result::Result::Ok(__Field::__F6),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F7),
                            "bmm_class" => ::core::result::Result::Ok(__Field::__F8),
                            "uid" => ::core::result::Result::Ok(__Field::__F9),
                            "ancestor_defs" => ::core::result::Result::Ok(__Field::__F10),
                            _ => ::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::v1_0::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<_> = 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("properties"),
                                );
                            }
                            __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_abstract"),
                                );
                            }
                            __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_override"),
                                );
                            }
                            __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("generic_parameter_defs"),
                                );
                            }
                            __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("source_schema_id"),
                                );
                            }
                            __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("bmm_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("uid"),
                                );
                            }
                            __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("ancestor_defs"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm_persistence::p_bmm_class::PBmmClassData {
                        documentation: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        ancestors: __s2,
                        properties: __s3.flatten(),
                        is_abstract: __s4.flatten(),
                        is_override: __s5.flatten(),
                        generic_parameter_defs: __s6.flatten(),
                        source_schema_id: __s7
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                        bmm_class: __s8.flatten(),
                        uid: __s9
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("uid"))?,
                        ancestor_defs: __s10,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_CLASS",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::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",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::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::v1_0::bmm_persistence::p_bmm_class::PBmmClass::PBmmClass(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_class::PBmmClass::PBmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_class::PBmmClass::PBmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_class::PBmmClass::PBmmEnumeration(::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")),
}
                    }
                    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",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(
                            crate::v1_0::bmm_persistence::p_bmm_class::PBmmClass::PBmmClass(
                                ::serde::Deserialize::deserialize(__rest)?,
                            ),
                        )
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_0::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::v1_0::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::v1_0::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::v1_0::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::v1_0::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::v1_0::bmm_persistence::p_bmm_container_property::PBmmContainerProperty::PBmmIndexedContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm_persistence::p_bmm_container_property::PBmmContainerProperty::PBmmContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::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::v1_0::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::v1_0::bmm_persistence::p_bmm_container_property::PBmmContainerProperty::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::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::v1_0::bmm_persistence::p_bmm_container_property::PBmmContainerProperty::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_0::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::v1_0::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::v1_0::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::v1_0::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::v1_0::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::v1_0::bmm_persistence::p_bmm_container_type::PBmmContainerType::PBmmIndexedContainerType(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm_persistence::p_bmm_container_type::PBmmContainerType::PBmmContainerType(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::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::v1_0::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::v1_0::bmm_persistence::p_bmm_container_type::PBmmContainerType::PBmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v1_0::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::v1_0::bmm_persistence::p_bmm_container_type::PBmmContainerType::PBmmContainerType(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::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.properties.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;
        }
        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.properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "properties", __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)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::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",
            "documentation",
            "generic_parameter_defs",
            "is_abstract",
            "is_override",
            "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,
        }
        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),
                            "properties" => ::core::result::Result::Ok(__Field::__F3),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F4),
                            "is_override" => ::core::result::Result::Ok(__Field::__F5),
                            "generic_parameter_defs" => ::core::result::Result::Ok(__Field::__F6),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F7),
                            "bmm_class" => ::core::result::Result::Ok(__Field::__F8),
                            "uid" => ::core::result::Result::Ok(__Field::__F9),
                            "ancestor_defs" => ::core::result::Result::Ok(__Field::__F10),
                            "item_names" => ::core::result::Result::Ok(__Field::__F11),
                            "item_values" => ::core::result::Result::Ok(__Field::__F12),
                            _ => ::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::v1_0::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<_> = None;
                let mut __s11: ::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("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("properties"),
                                );
                            }
                            __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_abstract"),
                                );
                            }
                            __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_override"),
                                );
                            }
                            __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("generic_parameter_defs"),
                                );
                            }
                            __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("source_schema_id"),
                                );
                            }
                            __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("bmm_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("uid"),
                                );
                            }
                            __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("ancestor_defs"),
                                );
                            }
                            __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("item_names"),
                                );
                            }
                            __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("item_values"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm_persistence::p_bmm_enumeration::PBmmEnumerationData {
                        documentation: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        ancestors: __s2,
                        properties: __s3.flatten(),
                        is_abstract: __s4.flatten(),
                        is_override: __s5.flatten(),
                        generic_parameter_defs: __s6.flatten(),
                        source_schema_id: __s7
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                        bmm_class: __s8.flatten(),
                        uid: __s9
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("uid"))?,
                        ancestor_defs: __s10,
                        item_names: __s11,
                        item_values: __s12,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_ENUMERATION",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::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::v1_0::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::v1_0::bmm_persistence::p_bmm_enumeration::PBmmEnumeration::PBmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_enumeration::PBmmEnumeration::PBmmEnumerationInteger(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_0::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::v1_0::bmm_persistence::p_bmm_enumeration::PBmmEnumeration::PBmmEnumeration(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_0::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.properties.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;
        }
        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.properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "properties", __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)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::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",
            "documentation",
            "generic_parameter_defs",
            "is_abstract",
            "is_override",
            "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,
        }
        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),
                            "properties" => ::core::result::Result::Ok(__Field::__F3),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F4),
                            "is_override" => ::core::result::Result::Ok(__Field::__F5),
                            "generic_parameter_defs" => ::core::result::Result::Ok(__Field::__F6),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F7),
                            "bmm_class" => ::core::result::Result::Ok(__Field::__F8),
                            "uid" => ::core::result::Result::Ok(__Field::__F9),
                            "ancestor_defs" => ::core::result::Result::Ok(__Field::__F10),
                            "item_names" => ::core::result::Result::Ok(__Field::__F11),
                            "item_values" => ::core::result::Result::Ok(__Field::__F12),
                            _ => ::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::v1_0::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<_> = None;
                let mut __s11: ::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(
                                    "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("properties"),
                                );
                            }
                            __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_abstract"),
                                );
                            }
                            __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_override"),
                                );
                            }
                            __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("generic_parameter_defs"),
                                );
                            }
                            __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("source_schema_id"),
                                );
                            }
                            __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("bmm_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("uid"),
                                );
                            }
                            __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("ancestor_defs"),
                                );
                            }
                            __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("item_names"),
                                );
                            }
                            __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("item_values"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_enumeration_integer::PBmmEnumerationInteger {
documentation: __s0.flatten(),
name: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
ancestors: __s2,
properties: __s3.flatten(),
is_abstract: __s4.flatten(),
is_override: __s5.flatten(),
generic_parameter_defs: __s6.flatten(),
source_schema_id: __s7.flatten().ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
bmm_class: __s8.flatten(),
uid: __s9.flatten().ok_or_else(|| ::serde::de::Error::missing_field("uid"))?,
ancestor_defs: __s10,
item_names: __s11,
item_values: __s12,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_ENUMERATION_INTEGER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::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.properties.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;
        }
        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.properties {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "properties", __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)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::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",
            "documentation",
            "generic_parameter_defs",
            "is_abstract",
            "is_override",
            "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,
        }
        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),
                            "properties" => ::core::result::Result::Ok(__Field::__F3),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F4),
                            "is_override" => ::core::result::Result::Ok(__Field::__F5),
                            "generic_parameter_defs" => ::core::result::Result::Ok(__Field::__F6),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F7),
                            "bmm_class" => ::core::result::Result::Ok(__Field::__F8),
                            "uid" => ::core::result::Result::Ok(__Field::__F9),
                            "ancestor_defs" => ::core::result::Result::Ok(__Field::__F10),
                            "item_names" => ::core::result::Result::Ok(__Field::__F11),
                            "item_values" => ::core::result::Result::Ok(__Field::__F12),
                            _ => ::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::v1_0::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<_> = None;
                let mut __s11: ::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(
                                    "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("properties"),
                                );
                            }
                            __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_abstract"),
                                );
                            }
                            __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_override"),
                                );
                            }
                            __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("generic_parameter_defs"),
                                );
                            }
                            __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("source_schema_id"),
                                );
                            }
                            __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("bmm_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("uid"),
                                );
                            }
                            __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("ancestor_defs"),
                                );
                            }
                            __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("item_names"),
                                );
                            }
                            __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("item_values"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::bmm_persistence::p_bmm_enumeration_string::PBmmEnumerationString {
                        documentation: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        ancestors: __s2,
                        properties: __s3.flatten(),
                        is_abstract: __s4.flatten(),
                        is_override: __s5.flatten(),
                        generic_parameter_defs: __s6.flatten(),
                        source_schema_id: __s7
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                        bmm_class: __s8.flatten(),
                        uid: __s9
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("uid"))?,
                        ancestor_defs: __s10,
                        item_names: __s11,
                        item_values: __s12,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_ENUMERATION_STRING",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::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::v1_0::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::v1_0::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::v1_0::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::v1_0::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::v1_0::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::v1_0::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::v1_0::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::v1_0::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 = 3usize;
        if self.bmm_type.is_some() {
            __n += 1;
        }
        if self.value_constraint.is_some() {
            __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)?;
        ::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::v1_0::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::v1_0::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<::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::v1_0::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.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("generic_parameter_defs")
                        })?,
                        generic_parameters: __s4,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_GENERIC_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::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::v1_0::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::v1_0::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::v1_0::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::v1_0::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::v1_0::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::v1_0::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::v1_0::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::v1_0::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::v1_0::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmClass(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmGenericParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmGenericProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmPackage(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSingleProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSinglePropertyOpen(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::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_CONTAINER_PROPERTY",
            "P_BMM_ENUMERATION",
            "P_BMM_ENUMERATION_INTEGER",
            "P_BMM_ENUMERATION_STRING",
            "P_BMM_GENERIC_PARAMETER",
            "P_BMM_GENERIC_PROPERTY",
            "P_BMM_INDEXED_CONTAINER_PROPERTY",
            "P_BMM_PACKAGE",
            "P_BMM_SINGLE_PROPERTY",
            "P_BMM_SINGLE_PROPERTY_OPEN",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::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::v1_0::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmClass(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmClass(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmClass(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmClass(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_GENERIC_PARAMETER" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmGenericParameter(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_GENERIC_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmGenericProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_PACKAGE" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmPackage(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSingleProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_PROPERTY_OPEN" => ::core::result::Result::Ok(crate::v1_0::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_CONTAINER_PROPERTY, P_BMM_ENUMERATION, P_BMM_ENUMERATION_INTEGER, P_BMM_ENUMERATION_STRING, P_BMM_GENERIC_PARAMETER, P_BMM_GENERIC_PROPERTY, P_BMM_INDEXED_CONTAINER_PROPERTY, P_BMM_PACKAGE, 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_CONTAINER_PROPERTY, P_BMM_ENUMERATION, P_BMM_ENUMERATION_INTEGER, P_BMM_ENUMERATION_STRING, P_BMM_GENERIC_PARAMETER, P_BMM_GENERIC_PROPERTY, P_BMM_INDEXED_CONTAINER_PROPERTY, P_BMM_PACKAGE, 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_CONTAINER_PROPERTY, P_BMM_ENUMERATION, P_BMM_ENUMERATION_INTEGER, P_BMM_ENUMERATION_STRING, P_BMM_GENERIC_PARAMETER, P_BMM_GENERIC_PROPERTY, P_BMM_INDEXED_CONTAINER_PROPERTY, P_BMM_PACKAGE, P_BMM_SINGLE_PROPERTY, P_BMM_SINGLE_PROPERTY_OPEN",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_0::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::v1_0::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::v1_0::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::v1_0::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::v1_0::bmm_persistence::p_bmm_package::PBmmPackage {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if !self.packages.is_empty() {
            __n += 1;
        }
        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")?;
        if !self.packages.is_empty() {
            ::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::v1_0::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::v1_0::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<_> = 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::v1_0::bmm_persistence::p_bmm_package::PBmmPackage {
                        packages: __s0.unwrap_or_default(),
                        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::v1_0::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 = 1usize;
        if !self.packages.is_empty() {
            __n += 1;
        }
        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",
        )?;
        if !self.packages.is_empty() {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "packages", &self.packages)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::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::v1_0::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<_> = 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::v1_0::bmm_persistence::p_bmm_package_container::PBmmPackageContainerData {
packages: __s0.unwrap_or_default(),
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_PACKAGE_CONTAINER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::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::v1_0::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmPackage(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmSchema(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_0::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmPackageContainer(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::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::v1_0::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::v1_0::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmPackage(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_PACKAGE_CONTAINER" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmPackageContainer(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SCHEMA" => ::core::result::Result::Ok(crate::v1_0::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::v1_0::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmPackageContainer(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::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::v1_0::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::v1_0::bmm_persistence::p_bmm_property::PBmmProperty::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_GENERIC_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_property::PBmmProperty::PBmmGenericProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_property::PBmmProperty::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_PROPERTY" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_property::PBmmProperty::PBmmSingleProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_PROPERTY_OPEN" => ::core::result::Result::Ok(crate::v1_0::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::v1_0::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.packages.is_empty() {
            __n += 1;
        }
        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;
        }
        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")?;
        if !self.packages.is_empty() {
            ::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,
            "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)?;
        }
        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::v1_0::bmm_persistence::p_bmm_schema::PBmmSchema {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "bmm_model",
            "bmm_version",
            "class_definitions",
            "includes",
            "model_name",
            "packages",
            "primitive_types",
            "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,
            __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),
                            "packages" => ::core::result::Result::Ok(__Field::__F0),
                            "rm_publisher" => ::core::result::Result::Ok(__Field::__F1),
                            "rm_release" => ::core::result::Result::Ok(__Field::__F2),
                            "bmm_version" => ::core::result::Result::Ok(__Field::__F3),
                            "includes" => ::core::result::Result::Ok(__Field::__F4),
                            "bmm_model" => ::core::result::Result::Ok(__Field::__F5),
                            "state" => ::core::result::Result::Ok(__Field::__F6),
                            "model_name" => ::core::result::Result::Ok(__Field::__F7),
                            "schema_name" => ::core::result::Result::Ok(__Field::__F8),
                            "schema_revision" => ::core::result::Result::Ok(__Field::__F9),
                            "schema_lifecycle_state" => ::core::result::Result::Ok(__Field::__F10),
                            "schema_author" => ::core::result::Result::Ok(__Field::__F11),
                            "schema_description" => ::core::result::Result::Ok(__Field::__F12),
                            "schema_contributors" => ::core::result::Result::Ok(__Field::__F13),
                            "primitive_types" => ::core::result::Result::Ok(__Field::__F14),
                            "class_definitions" => ::core::result::Result::Ok(__Field::__F15),
                            _ => ::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::v1_0::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<_> = 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<::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;
                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("bmm_version"),
                                );
                            }
                            __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_model"),
                                );
                            }
                            __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("state"),
                                );
                            }
                            __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("model_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_name"),
                                );
                            }
                            __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_revision"),
                                );
                            }
                            __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_lifecycle_state"),
                                );
                            }
                            __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_author"),
                                );
                            }
                            __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_description"),
                                );
                            }
                            __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("schema_contributors"),
                                );
                            }
                            __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("primitive_types"),
                                );
                            }
                            __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("class_definitions"),
                                );
                            }
                            __s15 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_schema::PBmmSchema {
                    packages: __s0.unwrap_or_default(),
                    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"))?,
                    bmm_version: __s3
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("bmm_version"))?,
                    includes: __s4.flatten(),
                    bmm_model: __s5.flatten(),
                    state: __s6
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("state"))?,
                    model_name: __s7.flatten(),
                    schema_name: __s8
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("schema_name"))?,
                    schema_revision: __s9
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("schema_revision"))?,
                    schema_lifecycle_state: __s10.flatten().ok_or_else(|| {
                        ::serde::de::Error::missing_field("schema_lifecycle_state")
                    })?,
                    schema_author: __s11
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("schema_author"))?,
                    schema_description: __s12
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("schema_description"))?,
                    schema_contributors: __s13,
                    primitive_types: __s14,
                    class_definitions: __s15,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_SCHEMA",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::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.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, "P_BMM_SCHEMA_DESCRIPTOR", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "P_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::v1_0::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_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,
                                    "P_BMM_SCHEMA_DESCRIPTOR",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_0::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;
                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("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::v1_0::bmm_persistence::p_bmm_schema_descriptor::PBmmSchemaDescriptor {
                        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,
            "P_BMM_SCHEMA_DESCRIPTOR",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_0::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::v1_0::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::v1_0::bmm_persistence::p_bmm_type::PBmmType::PBmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_GENERIC_TYPE" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_type::PBmmType::PBmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_type::PBmmType::PBmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_OPEN_TYPE" => ::core::result::Result::Ok(crate::v1_0::bmm_persistence::p_bmm_type::PBmmType::PBmmOpenType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v1_0::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::v1_0::obsolete_elom::types::type_def_boolean::TypeDefBoolean {
    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, "TYPE_DEF_BOOLEAN", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_BOOLEAN")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::types::type_def_boolean::TypeDefBoolean
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_BOOLEAN",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::obsolete_elom::types::type_def_boolean::TypeDefBoolean;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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("TYPE_DEF_BOOLEAN"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::obsolete_elom::types::type_def_boolean::TypeDefBoolean {
                        type_name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("Boolean")),
                        type_anchor: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_BOOLEAN",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::obsolete_elom::types::type_def_date::TypeDefDate {
    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, "TYPE_DEF_DATE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_DATE")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::types::type_def_date::TypeDefDate
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_DATE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::obsolete_elom::types::type_def_date::TypeDefDate;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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("TYPE_DEF_DATE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::obsolete_elom::types::type_def_date::TypeDefDate {
                        type_name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("Date")),
                        type_anchor: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_DATE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::obsolete_elom::types::type_def_date_time::TypeDefDateTime {
    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, "TYPE_DEF_DATE_TIME", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_DATE_TIME")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::types::type_def_date_time::TypeDefDateTime
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_DATE_TIME",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::obsolete_elom::types::type_def_date_time::TypeDefDateTime;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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("TYPE_DEF_DATE_TIME"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::obsolete_elom::types::type_def_date_time::TypeDefDateTime {
                        type_name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("Date_time")),
                        type_anchor: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_DATE_TIME",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::obsolete_elom::types::type_def_duration::TypeDefDuration {
    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, "TYPE_DEF_DURATION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_DURATION")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::types::type_def_duration::TypeDefDuration
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_DURATION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::obsolete_elom::types::type_def_duration::TypeDefDuration;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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("TYPE_DEF_DURATION"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::obsolete_elom::types::type_def_duration::TypeDefDuration {
                        type_name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("Duration")),
                        type_anchor: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_DURATION",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::obsolete_elom::types::type_def_integer::TypeDefInteger {
    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, "TYPE_DEF_INTEGER", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_INTEGER")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::types::type_def_integer::TypeDefInteger
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_INTEGER",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::obsolete_elom::types::type_def_integer::TypeDefInteger;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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("TYPE_DEF_INTEGER"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::obsolete_elom::types::type_def_integer::TypeDefInteger {
                        type_name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("Integer")),
                        type_anchor: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_INTEGER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::obsolete_elom::types::type_def_object_ref::TypeDefObjectRef
{
    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, "TYPE_DEF_OBJECT_REF", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_OBJECT_REF")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::types::type_def_object_ref::TypeDefObjectRef
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_OBJECT_REF",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::obsolete_elom::types::type_def_object_ref::TypeDefObjectRef;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_OBJECT_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("TYPE_DEF_OBJECT_REF"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::obsolete_elom::types::type_def_object_ref::TypeDefObjectRef {
                        type_name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("Object_ref")),
                        type_anchor: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_OBJECT_REF",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::obsolete_elom::types::type_def_real::TypeDefReal {
    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, "TYPE_DEF_REAL", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_REAL")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::types::type_def_real::TypeDefReal
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_REAL",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::obsolete_elom::types::type_def_real::TypeDefReal;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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("TYPE_DEF_REAL"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::obsolete_elom::types::type_def_real::TypeDefReal {
                        type_name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("Real")),
                        type_anchor: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_REAL",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::obsolete_elom::types::type_def_string::TypeDefString {
    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, "TYPE_DEF_STRING", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_STRING")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::types::type_def_string::TypeDefString
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_STRING",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::obsolete_elom::types::type_def_string::TypeDefString;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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("TYPE_DEF_STRING"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::obsolete_elom::types::type_def_string::TypeDefString {
                        type_name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("String")),
                        type_anchor: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_STRING",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_0::obsolete_elom::types::type_def_terminology_code::TypeDefTerminologyCode
{
    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, "TYPE_DEF_TERMINOLOGY_CODE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "TYPE_DEF_TERMINOLOGY_CODE",
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::types::type_def_terminology_code::TypeDefTerminologyCode
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_TERMINOLOGY_CODE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::obsolete_elom::types::type_def_terminology_code::TypeDefTerminologyCode;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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(
                                    "TYPE_DEF_TERMINOLOGY_CODE",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_0::obsolete_elom::types::type_def_terminology_code::TypeDefTerminologyCode {
type_name: __s0.flatten().unwrap_or(::std::string::String::from("Terminology_code")),
type_anchor: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_TERMINOLOGY_CODE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::obsolete_elom::types::type_def_time::TypeDefTime {
    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, "TYPE_DEF_TIME", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_TIME")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::types::type_def_time::TypeDefTime
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_TIME",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::obsolete_elom::types::type_def_time::TypeDefTime;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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("TYPE_DEF_TIME"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::obsolete_elom::types::type_def_time::TypeDefTime {
                        type_name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("Time")),
                        type_anchor: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_TIME",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_0::obsolete_elom::types::type_def_uri::TypeDefUri {
    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, "TYPE_DEF_URI", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_URI")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_0::obsolete_elom::types::type_def_uri::TypeDefUri
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_URI",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_0::obsolete_elom::types::type_def_uri::TypeDefUri;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_URI` 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("TYPE_DEF_URI"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_0::obsolete_elom::types::type_def_uri::TypeDefUri {
                        type_name: __s0.flatten().unwrap_or(::std::string::String::from("Uri")),
                        type_anchor: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_URI",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm::core::bmm_class::BmmClassData {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 7usize;
        if self.documentation.is_some() {
            __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;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_CLASS", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "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 {
            ::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_abstract",
            &self.is_abstract,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_primitive_type",
            &self.is_primitive_type,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_override",
            &self.is_override,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::bmm::core::bmm_class::BmmClassData {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "ancestors",
            "documentation",
            "immediate_descendants",
            "is_abstract",
            "is_override",
            "is_primitive_type",
            "name",
            "package",
            "properties",
            "source_schema_id",
        ];
        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),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F2),
                            "package" => ::core::result::Result::Ok(__Field::__F3),
                            "properties" => ::core::result::Result::Ok(__Field::__F4),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F5),
                            "immediate_descendants" => ::core::result::Result::Ok(__Field::__F6),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F7),
                            "is_primitive_type" => ::core::result::Result::Ok(__Field::__F8),
                            "is_override" => ::core::result::Result::Ok(__Field::__F9),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_CLASS",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::bmm::core::bmm_class::BmmClassData;
            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 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;
                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_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("package"),
                                );
                            }
                            __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("source_schema_id"),
                                );
                            }
                            __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("immediate_descendants"),
                                );
                            }
                            __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_primitive_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("is_override"),
                                );
                            }
                            __s9 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_class::BmmClassData {
                    documentation: __s0.flatten(),
                    name: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                    ancestors: __s2.flatten(),
                    package: __s3
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("package"))?,
                    properties: __s4.flatten(),
                    source_schema_id: __s5
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                    immediate_descendants: __s6,
                    is_abstract: __s7
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("is_abstract"))?,
                    is_primitive_type: __s8
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("is_primitive_type"))?,
                    is_override: __s9
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("is_override"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "BMM_CLASS", __FIELDS, __Visitor)
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::bmm::core::bmm_class::BmmClass {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_CLASS",
            "BMM_ENUMERATION",
            "BMM_ENUMERATION_INTEGER",
            "BMM_ENUMERATION_STRING",
            "BMM_GENERIC_CLASS",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::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_CLASS" => ::core::result::Result::Ok(
                                crate::v1_1::bmm::core::bmm_class::BmmClass::BmmClass(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_ENUMERATION" => ::core::result::Result::Ok(
                                crate::v1_1::bmm::core::bmm_class::BmmClass::BmmEnumeration(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(
                                crate::v1_1::bmm::core::bmm_class::BmmClass::BmmEnumeration(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(
                                crate::v1_1::bmm::core::bmm_class::BmmClass::BmmEnumeration(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_GENERIC_CLASS" => ::core::result::Result::Ok(
                                crate::v1_1::bmm::core::bmm_class::BmmClass::BmmGenericClass(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            __other => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unexpected_type(
                                    "BMM_CLASS",
                                    __other,
                                    "BMM_CLASS, BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_GENERIC_CLASS",
                                ),
                            ),
                        }
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_CLASS",
                            &__other,
                            "BMM_CLASS, BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_GENERIC_CLASS",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(
                            crate::v1_1::bmm::core::bmm_class::BmmClass::BmmClass(
                                ::serde::Deserialize::deserialize(__rest)?,
                            ),
                        )
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::bmm::core::bmm_classifier::BmmClassifier {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_CLASS",
            "BMM_CONTAINER_TYPE",
            "BMM_ENUMERATION",
            "BMM_ENUMERATION_INTEGER",
            "BMM_ENUMERATION_STRING",
            "BMM_GENERIC_CLASS",
            "BMM_GENERIC_PARAMETER",
            "BMM_GENERIC_TYPE",
            "BMM_INDEXED_CONTAINER_TYPE",
            "BMM_OPEN_TYPE",
            "BMM_SIMPLE_TYPE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::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_CLASS" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_classifier::BmmClassifier::BmmClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_classifier::BmmClassifier::BmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_classifier::BmmClassifier::BmmClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_classifier::BmmClassifier::BmmClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_classifier::BmmClassifier::BmmClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_CLASS" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_classifier::BmmClassifier::BmmClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_PARAMETER" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_classifier::BmmClassifier::BmmGenericParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_classifier::BmmClassifier::BmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_classifier::BmmClassifier::BmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_OPEN_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_classifier::BmmClassifier::BmmOpenType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_classifier::BmmClassifier::BmmSimpleType(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_CLASSIFIER", __other, "BMM_CLASS, BMM_CONTAINER_TYPE, BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_GENERIC_CLASS, BMM_GENERIC_PARAMETER, BMM_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_OPEN_TYPE, BMM_SIMPLE_TYPE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_CLASSIFIER",
                            &__other,
                            "BMM_CLASS, BMM_CONTAINER_TYPE, BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_GENERIC_CLASS, BMM_GENERIC_PARAMETER, BMM_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_OPEN_TYPE, BMM_SIMPLE_TYPE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_CLASSIFIER",
                            "BMM_CLASS, BMM_CONTAINER_TYPE, BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_GENERIC_CLASS, BMM_GENERIC_PARAMETER, BMM_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_OPEN_TYPE, BMM_SIMPLE_TYPE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_1::bmm::core::bmm_container_property::BmmContainerProperty {
    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_mandatory.is_some() {
            __n += 1;
        }
        if self.is_computed.is_some() {
            __n += 1;
        }
        if self.is_im_runtime.is_some() {
            __n += 1;
        }
        if self.is_im_infrastructure.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",
        )?;
        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)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        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.cardinality {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "cardinality", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm::core::bmm_container_property::BmmContainerProperty
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "cardinality",
            "documentation",
            "is_computed",
            "is_im_infrastructure",
            "is_im_runtime",
            "is_mandatory",
            "name",
            "type",
        ];
        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),
                            "type" => ::core::result::Result::Ok(__Field::__F4),
                            "is_im_runtime" => ::core::result::Result::Ok(__Field::__F5),
                            "is_im_infrastructure" => ::core::result::Result::Ok(__Field::__F6),
                            "cardinality" => ::core::result::Result::Ok(__Field::__F7),
                            _ => ::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::v1_1::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 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(
                                    "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("type"),
                                );
                            }
                            __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("is_im_infrastructure"),
                                );
                            }
                            __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("cardinality"),
                                );
                            }
                            __s7 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm::core::bmm_container_property::BmmContainerProperty {
                        documentation: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        is_mandatory: __s2.flatten(),
                        is_computed: __s3.flatten(),
                        r#type: __s4
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                        is_im_runtime: __s5.flatten(),
                        is_im_infrastructure: __s6.flatten(),
                        cardinality: __s7.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_CONTAINER_PROPERTY",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::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.documentation.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")?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "container_type",
            &self.container_type,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "base_type", &self.base_type)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm::core::bmm_container_type::BmmContainerTypeData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["base_type", "container_type", "documentation"];
        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),
                            "container_type" => ::core::result::Result::Ok(__Field::__F1),
                            "base_type" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::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::v1_1::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;
                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("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("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("base_type"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm::core::bmm_container_type::BmmContainerTypeData {
                        documentation: __s0.flatten(),
                        container_type: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("container_type"))?,
                        base_type: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("base_type"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_CONTAINER_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm::core::bmm_container_type::BmmContainerType::BmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm::core::bmm_container_type::BmmContainerType::BmmContainerType(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm::core::bmm_definitions::BmmDefinitionsData {},
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_DEFINITIONS",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmClass(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmContainerType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmGenericParameter(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmGenericType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmOpenType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmPackageContainer(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmProperty(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmSimpleType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::ReferenceModelAccess(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::SchemaDescriptor(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmDefinitions(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_CLASS",
            "BMM_CONTAINER_PROPERTY",
            "BMM_CONTAINER_TYPE",
            "BMM_DEFINITIONS",
            "BMM_ENUMERATION",
            "BMM_ENUMERATION_INTEGER",
            "BMM_ENUMERATION_STRING",
            "BMM_GENERIC_CLASS",
            "BMM_GENERIC_PARAMETER",
            "BMM_GENERIC_TYPE",
            "BMM_INDEXED_CONTAINER_TYPE",
            "BMM_MODEL",
            "BMM_OPEN_TYPE",
            "BMM_PACKAGE",
            "BMM_PACKAGE_CONTAINER",
            "BMM_PROPERTY",
            "BMM_SIMPLE_TYPE",
            "P_BMM_SCHEMA_DESCRIPTOR",
            "REFERENCE_MODEL_ACCESS",
            "SCHEMA_DESCRIPTOR",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::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_CLASS" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_DEFINITIONS" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmDefinitions(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_CLASS" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_PARAMETER" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmGenericParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_MODEL" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmPackageContainer(::serde::Deserialize::deserialize(__rest)?)),
"BMM_OPEN_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmOpenType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PACKAGE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmPackageContainer(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PACKAGE_CONTAINER" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmPackageContainer(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmSimpleType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SCHEMA_DESCRIPTOR" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::SchemaDescriptor(::serde::Deserialize::deserialize(__rest)?)),
"REFERENCE_MODEL_ACCESS" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_definitions::BmmDefinitions::ReferenceModelAccess(::serde::Deserialize::deserialize(__rest)?)),
"SCHEMA_DESCRIPTOR" => ::core::result::Result::Ok(crate::v1_1::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_CLASS, BMM_CONTAINER_PROPERTY, BMM_CONTAINER_TYPE, BMM_DEFINITIONS, BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_GENERIC_CLASS, BMM_GENERIC_PARAMETER, BMM_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_MODEL, BMM_OPEN_TYPE, BMM_PACKAGE, BMM_PACKAGE_CONTAINER, BMM_PROPERTY, BMM_SIMPLE_TYPE, 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_CLASS, BMM_CONTAINER_PROPERTY, BMM_CONTAINER_TYPE, BMM_DEFINITIONS, BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_GENERIC_CLASS, BMM_GENERIC_PARAMETER, BMM_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_MODEL, BMM_OPEN_TYPE, BMM_PACKAGE, BMM_PACKAGE_CONTAINER, BMM_PROPERTY, BMM_SIMPLE_TYPE, 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::v1_1::bmm::core::bmm_definitions::BmmDefinitions::BmmDefinitions(
                                ::serde::Deserialize::deserialize(__rest)?,
                            ),
                        )
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_1::bmm::core::bmm_enumeration::BmmEnumerationData {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 8usize;
        if self.documentation.is_some() {
            __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.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")?;
        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 {
            ::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_abstract",
            &self.is_abstract,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_primitive_type",
            &self.is_primitive_type,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_override",
            &self.is_override,
        )?;
        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::serialize_field(
            &mut __st,
            "underlying_type_name",
            &self.underlying_type_name,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm::core::bmm_enumeration::BmmEnumerationData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "ancestors",
            "documentation",
            "immediate_descendants",
            "is_abstract",
            "is_override",
            "is_primitive_type",
            "item_names",
            "item_values",
            "name",
            "package",
            "properties",
            "source_schema_id",
            "underlying_type_name",
        ];
        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),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F2),
                            "package" => ::core::result::Result::Ok(__Field::__F3),
                            "properties" => ::core::result::Result::Ok(__Field::__F4),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F5),
                            "immediate_descendants" => ::core::result::Result::Ok(__Field::__F6),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F7),
                            "is_primitive_type" => ::core::result::Result::Ok(__Field::__F8),
                            "is_override" => ::core::result::Result::Ok(__Field::__F9),
                            "item_names" => ::core::result::Result::Ok(__Field::__F10),
                            "item_values" => ::core::result::Result::Ok(__Field::__F11),
                            "underlying_type_name" => ::core::result::Result::Ok(__Field::__F12),
                            _ => ::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::v1_1::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<::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<_> = 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("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("package"),
                                );
                            }
                            __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("source_schema_id"),
                                );
                            }
                            __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("immediate_descendants"),
                                );
                            }
                            __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_primitive_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("is_override"),
                                );
                            }
                            __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("item_names"),
                                );
                            }
                            __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("item_values"),
                                );
                            }
                            __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("underlying_type_name"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm::core::bmm_enumeration::BmmEnumerationData {
                        documentation: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        ancestors: __s2.flatten(),
                        package: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("package"))?,
                        properties: __s4.flatten(),
                        source_schema_id: __s5
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                        immediate_descendants: __s6,
                        is_abstract: __s7
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_abstract"))?,
                        is_primitive_type: __s8.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("is_primitive_type")
                        })?,
                        is_override: __s9
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_override"))?,
                        item_names: __s10,
                        item_values: __s11,
                        underlying_type_name: __s12.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("underlying_type_name")
                        })?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_ENUMERATION",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::bmm::core::bmm_enumeration::BmmEnumeration::BmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_enumeration::BmmEnumeration::BmmEnumerationInteger(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm::core::bmm_enumeration::BmmEnumeration::BmmEnumeration(
                                ::serde::Deserialize::deserialize(__rest)?,
                            ),
                        )
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_1::bmm::core::bmm_enumeration_integer::BmmEnumerationInteger {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 8usize;
        if self.documentation.is_some() {
            __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.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",
        )?;
        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 {
            ::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_abstract",
            &self.is_abstract,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_primitive_type",
            &self.is_primitive_type,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_override",
            &self.is_override,
        )?;
        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::serialize_field(
            &mut __st,
            "underlying_type_name",
            &self.underlying_type_name,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm::core::bmm_enumeration_integer::BmmEnumerationInteger
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "ancestors",
            "documentation",
            "immediate_descendants",
            "is_abstract",
            "is_override",
            "is_primitive_type",
            "item_names",
            "item_values",
            "name",
            "package",
            "properties",
            "source_schema_id",
            "underlying_type_name",
        ];
        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),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F2),
                            "package" => ::core::result::Result::Ok(__Field::__F3),
                            "properties" => ::core::result::Result::Ok(__Field::__F4),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F5),
                            "immediate_descendants" => ::core::result::Result::Ok(__Field::__F6),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F7),
                            "is_primitive_type" => ::core::result::Result::Ok(__Field::__F8),
                            "is_override" => ::core::result::Result::Ok(__Field::__F9),
                            "item_names" => ::core::result::Result::Ok(__Field::__F10),
                            "item_values" => ::core::result::Result::Ok(__Field::__F11),
                            "underlying_type_name" => ::core::result::Result::Ok(__Field::__F12),
                            _ => ::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::v1_1::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<::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<_> = 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(
                                    "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("package"),
                                );
                            }
                            __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("source_schema_id"),
                                );
                            }
                            __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("immediate_descendants"),
                                );
                            }
                            __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_primitive_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("is_override"),
                                );
                            }
                            __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("item_names"),
                                );
                            }
                            __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("item_values"),
                                );
                            }
                            __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("underlying_type_name"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm::core::bmm_enumeration_integer::BmmEnumerationInteger {
                        documentation: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        ancestors: __s2.flatten(),
                        package: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("package"))?,
                        properties: __s4.flatten(),
                        source_schema_id: __s5
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                        immediate_descendants: __s6,
                        is_abstract: __s7
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_abstract"))?,
                        is_primitive_type: __s8.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("is_primitive_type")
                        })?,
                        is_override: __s9
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_override"))?,
                        item_names: __s10,
                        item_values: __s11,
                        underlying_type_name: __s12
                            .flatten()
                            .unwrap_or(::std::string::String::from("INTEGER")),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_ENUMERATION_INTEGER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::bmm::core::bmm_enumeration_string::BmmEnumerationString {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 8usize;
        if self.documentation.is_some() {
            __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.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",
        )?;
        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 {
            ::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_abstract",
            &self.is_abstract,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_primitive_type",
            &self.is_primitive_type,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_override",
            &self.is_override,
        )?;
        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::serialize_field(
            &mut __st,
            "underlying_type_name",
            &self.underlying_type_name,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm::core::bmm_enumeration_string::BmmEnumerationString
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "ancestors",
            "documentation",
            "immediate_descendants",
            "is_abstract",
            "is_override",
            "is_primitive_type",
            "item_names",
            "item_values",
            "name",
            "package",
            "properties",
            "source_schema_id",
            "underlying_type_name",
        ];
        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),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F2),
                            "package" => ::core::result::Result::Ok(__Field::__F3),
                            "properties" => ::core::result::Result::Ok(__Field::__F4),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F5),
                            "immediate_descendants" => ::core::result::Result::Ok(__Field::__F6),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F7),
                            "is_primitive_type" => ::core::result::Result::Ok(__Field::__F8),
                            "is_override" => ::core::result::Result::Ok(__Field::__F9),
                            "item_names" => ::core::result::Result::Ok(__Field::__F10),
                            "item_values" => ::core::result::Result::Ok(__Field::__F11),
                            "underlying_type_name" => ::core::result::Result::Ok(__Field::__F12),
                            _ => ::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::v1_1::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<::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<_> = 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(
                                    "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("package"),
                                );
                            }
                            __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("source_schema_id"),
                                );
                            }
                            __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("immediate_descendants"),
                                );
                            }
                            __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_primitive_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("is_override"),
                                );
                            }
                            __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("item_names"),
                                );
                            }
                            __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("item_values"),
                                );
                            }
                            __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("underlying_type_name"),
                                );
                            }
                            __s12 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm::core::bmm_enumeration_string::BmmEnumerationString {
                        documentation: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        ancestors: __s2.flatten(),
                        package: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("package"))?,
                        properties: __s4.flatten(),
                        source_schema_id: __s5
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                        immediate_descendants: __s6,
                        is_abstract: __s7
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_abstract"))?,
                        is_primitive_type: __s8.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("is_primitive_type")
                        })?,
                        is_override: __s9
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_override"))?,
                        item_names: __s10,
                        item_values: __s11,
                        underlying_type_name: __s12
                            .flatten()
                            .unwrap_or(::std::string::String::from("STRING")),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_ENUMERATION_STRING",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::bmm::core::bmm_generic_class::BmmGenericClass {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 8usize;
        if self.documentation.is_some() {
            __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;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_GENERIC_CLASS", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_GENERIC_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 {
            ::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_abstract",
            &self.is_abstract,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_primitive_type",
            &self.is_primitive_type,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "is_override",
            &self.is_override,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "generic_parameters",
            &self.generic_parameters,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::bmm::core::bmm_generic_class::BmmGenericClass {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "ancestors",
            "documentation",
            "generic_parameters",
            "immediate_descendants",
            "is_abstract",
            "is_override",
            "is_primitive_type",
            "name",
            "package",
            "properties",
            "source_schema_id",
        ];
        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),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "ancestors" => ::core::result::Result::Ok(__Field::__F2),
                            "package" => ::core::result::Result::Ok(__Field::__F3),
                            "properties" => ::core::result::Result::Ok(__Field::__F4),
                            "source_schema_id" => ::core::result::Result::Ok(__Field::__F5),
                            "immediate_descendants" => ::core::result::Result::Ok(__Field::__F6),
                            "is_abstract" => ::core::result::Result::Ok(__Field::__F7),
                            "is_primitive_type" => ::core::result::Result::Ok(__Field::__F8),
                            "is_override" => ::core::result::Result::Ok(__Field::__F9),
                            "generic_parameters" => ::core::result::Result::Ok(__Field::__F10),
                            _ => ::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::v1_1::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<::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_GENERIC_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("package"),
                                );
                            }
                            __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("source_schema_id"),
                                );
                            }
                            __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("immediate_descendants"),
                                );
                            }
                            __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_primitive_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("is_override"),
                                );
                            }
                            __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("generic_parameters"),
                                );
                            }
                            __s10 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm::core::bmm_generic_class::BmmGenericClass {
                        documentation: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        ancestors: __s2.flatten(),
                        package: __s3
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("package"))?,
                        properties: __s4.flatten(),
                        source_schema_id: __s5
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("source_schema_id"))?,
                        immediate_descendants: __s6,
                        is_abstract: __s7
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_abstract"))?,
                        is_primitive_type: __s8.flatten().ok_or_else(|| {
                            ::serde::de::Error::missing_field("is_primitive_type")
                        })?,
                        is_override: __s9
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("is_override"))?,
                        generic_parameters: __s10.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::v1_1::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.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",
        )?;
        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.inheritance_precursor {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "inheritance_precursor",
                __v,
            )?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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",
            "inheritance_precursor",
            "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),
                            "inheritance_precursor" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::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::v1_1::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;
                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("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("inheritance_precursor"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm::core::bmm_generic_parameter::BmmGenericParameter {
                        documentation: __s0.flatten(),
                        name: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        conforms_to_type: __s2.flatten(),
                        inheritance_precursor: __s3.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_GENERIC_PARAMETER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::bmm::core::bmm_generic_type::BmmGenericType {
    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.generic_parameters.is_empty() {
            __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.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if !self.generic_parameters.is_empty() {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "generic_parameters",
                &self.generic_parameters,
            )?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "base_class", &self.base_class)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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", "documentation", "generic_parameters"];
        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),
                            "generic_parameters" => ::core::result::Result::Ok(__Field::__F1),
                            "base_class" => ::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::v1_1::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<_> = 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("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("generic_parameters"),
                                );
                            }
                            __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("base_class"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm::core::bmm_generic_type::BmmGenericType {
                        documentation: __s0.flatten(),
                        generic_parameters: __s1.unwrap_or_default(),
                        base_class: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("base_class"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_GENERIC_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::bmm::core::bmm_include_spec::BmmIncludeSpec {
    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_INCLUDE_SPEC", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_INCLUDE_SPEC")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "id", &self.id)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::bmm::core::bmm_include_spec::BmmIncludeSpec {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["id"];
        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),
                            "id" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_INCLUDE_SPEC",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::bmm::core::bmm_include_spec::BmmIncludeSpec;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_INCLUDE_SPEC` 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_INCLUDE_SPEC"),
                            )?;
                        }
                        __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)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm::core::bmm_include_spec::BmmIncludeSpec {
                        id: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("id"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_INCLUDE_SPEC",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_1::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.documentation.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",
        )?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "container_type",
            &self.container_type,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "base_type", &self.base_type)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "index_type", &self.index_type)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm::core::bmm_indexed_container_type::BmmIndexedContainerType
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["base_type", "container_type", "documentation", "index_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),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "container_type" => ::core::result::Result::Ok(__Field::__F1),
                            "base_type" => ::core::result::Result::Ok(__Field::__F2),
                            "index_type" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::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::v1_1::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;
                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("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("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("base_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("index_type"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm::core::bmm_indexed_container_type::BmmIndexedContainerType {
                        documentation: __s0.flatten(),
                        container_type: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("container_type"))?,
                        base_type: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("base_type"))?,
                        index_type: __s3
                            .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::v1_1::bmm::core::bmm_model::BmmModel {
    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;
        }
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.packages.is_some() {
            __n += 1;
        }
        if self.class_definitions.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,
            "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,
            )?;
        }
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.packages {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "packages", __v)?;
        }
        if let Some(__v) = &self.class_definitions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "class_definitions", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::bmm::core::bmm_model::BmmModel {
    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",
            "class_definitions",
            "documentation",
            "packages",
            "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,
        }
        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)
                            }
                            "documentation" => ::core::result::Result::Ok(__Field::__F12),
                            "packages" => ::core::result::Result::Ok(__Field::__F13),
                            "class_definitions" => ::core::result::Result::Ok(__Field::__F14),
                            _ => ::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::v1_1::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;
                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;
                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;
                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("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)?);
                        }
                        __Field::__F12 => {
                            if __s12.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("documentation"),
                                );
                            }
                            __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("packages"),
                                );
                            }
                            __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("class_definitions"),
                                );
                            }
                            __s14 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_model::BmmModel {
                    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(),
                    documentation: __s12.flatten(),
                    packages: __s13.flatten(),
                    class_definitions: __s14.flatten(),
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(__deserializer, "BMM_MODEL", __FIELDS, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_1::bmm::core::bmm_model_element::BmmModelElement {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmClass(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmContainerType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmGenericParameter(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmGenericType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmOpenType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmPackageContainer(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmProperty(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmSimpleType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::bmm::core::bmm_model_element::BmmModelElement {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_CLASS",
            "BMM_CONTAINER_PROPERTY",
            "BMM_CONTAINER_TYPE",
            "BMM_ENUMERATION",
            "BMM_ENUMERATION_INTEGER",
            "BMM_ENUMERATION_STRING",
            "BMM_GENERIC_CLASS",
            "BMM_GENERIC_PARAMETER",
            "BMM_GENERIC_TYPE",
            "BMM_INDEXED_CONTAINER_TYPE",
            "BMM_MODEL",
            "BMM_OPEN_TYPE",
            "BMM_PACKAGE",
            "BMM_PACKAGE_CONTAINER",
            "BMM_PROPERTY",
            "BMM_SIMPLE_TYPE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::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_CLASS" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_CLASS" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_PARAMETER" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmGenericParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_MODEL" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmPackageContainer(::serde::Deserialize::deserialize(__rest)?)),
"BMM_OPEN_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmOpenType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PACKAGE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmPackageContainer(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PACKAGE_CONTAINER" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmPackageContainer(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_model_element::BmmModelElement::BmmSimpleType(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_MODEL_ELEMENT", __other, "BMM_CLASS, BMM_CONTAINER_PROPERTY, BMM_CONTAINER_TYPE, BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_GENERIC_CLASS, BMM_GENERIC_PARAMETER, BMM_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_MODEL, BMM_OPEN_TYPE, BMM_PACKAGE, BMM_PACKAGE_CONTAINER, BMM_PROPERTY, BMM_SIMPLE_TYPE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_MODEL_ELEMENT",
                            &__other,
                            "BMM_CLASS, BMM_CONTAINER_PROPERTY, BMM_CONTAINER_TYPE, BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_GENERIC_CLASS, BMM_GENERIC_PARAMETER, BMM_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_MODEL, BMM_OPEN_TYPE, BMM_PACKAGE, BMM_PACKAGE_CONTAINER, BMM_PROPERTY, BMM_SIMPLE_TYPE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_MODEL_ELEMENT",
                            "BMM_CLASS, BMM_CONTAINER_PROPERTY, BMM_CONTAINER_TYPE, BMM_ENUMERATION, BMM_ENUMERATION_INTEGER, BMM_ENUMERATION_STRING, BMM_GENERIC_CLASS, BMM_GENERIC_PARAMETER, BMM_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_MODEL, BMM_OPEN_TYPE, BMM_PACKAGE, BMM_PACKAGE_CONTAINER, BMM_PROPERTY, BMM_SIMPLE_TYPE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_1::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;
        if self.documentation.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_OPEN_TYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_OPEN_TYPE")?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "generic_constraint",
            &self.generic_constraint,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::bmm::core::bmm_open_type::BmmOpenType {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["documentation", "generic_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),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "generic_constraint" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::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::v1_1::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;
                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_OPEN_TYPE"),
                            )?;
                        }
                        __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("generic_constraint"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_open_type::BmmOpenType {
                    documentation: __s0.flatten(),
                    generic_constraint: __s1
                        .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::v1_1::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.packages.is_some() {
            __n += 1;
        }
        if self.classes.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")?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.packages {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "packages", __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)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::bmm::core::bmm_package::BmmPackage {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["classes", "documentation", "name", "packages"];
        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),
                            "packages" => ::core::result::Result::Ok(__Field::__F1),
                            "name" => ::core::result::Result::Ok(__Field::__F2),
                            "classes" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::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::v1_1::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<_> = 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("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("packages"),
                                );
                            }
                            __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)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_package::BmmPackage {
                    documentation: __s0.flatten(),
                    packages: __s1.flatten(),
                    name: __s2
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                    classes: __s3,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_PACKAGE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::bmm::core::bmm_package_container::BmmPackageContainerData {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 1usize;
        if self.documentation.is_some() {
            __n += 1;
        }
        if self.packages.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_PACKAGE_CONTAINER", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "BMM_PACKAGE_CONTAINER",
        )?;
        if let Some(__v) = &self.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __v)?;
        }
        if let Some(__v) = &self.packages {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "packages", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm::core::bmm_package_container::BmmPackageContainerData
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["documentation", "packages"];
        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),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "packages" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_PACKAGE_CONTAINER",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::bmm::core::bmm_package_container::BmmPackageContainerData;
            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 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_PACKAGE_CONTAINER",
                                ),
                            )?;
                        }
                        __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("packages"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm::core::bmm_package_container::BmmPackageContainerData {
                        documentation: __s0.flatten(),
                        packages: __s1.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_PACKAGE_CONTAINER",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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", "BMM_PACKAGE_CONTAINER"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::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::v1_1::bmm::core::bmm_package_container::BmmPackageContainer::BmmModel(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PACKAGE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_package_container::BmmPackageContainer::BmmPackage(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PACKAGE_CONTAINER" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_package_container::BmmPackageContainer::BmmPackageContainer(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_PACKAGE_CONTAINER", __other, "BMM_MODEL, BMM_PACKAGE, BMM_PACKAGE_CONTAINER")),
}
                    }
                    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, BMM_PACKAGE_CONTAINER",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_package_container::BmmPackageContainer::BmmPackageContainer(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl<T: ::serde::Serialize> ::serde::Serialize
    for crate::v1_1::bmm::core::bmm_property::BmmPropertyData<T>
{
    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_mandatory.is_some() {
            __n += 1;
        }
        if self.is_computed.is_some() {
            __n += 1;
        }
        if self.is_im_runtime.is_some() {
            __n += 1;
        }
        if self.is_im_infrastructure.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "BMM_PROPERTY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_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)?;
        }
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        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)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de, T: ::serde::de::DeserializeOwned> ::serde::Deserialize<'de>
    for crate::v1_1::bmm::core::bmm_property::BmmPropertyData<T>
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &[
            "documentation",
            "is_computed",
            "is_im_infrastructure",
            "is_im_runtime",
            "is_mandatory",
            "name",
            "type",
        ];
        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),
                            "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),
                            "type" => ::core::result::Result::Ok(__Field::__F4),
                            "is_im_runtime" => ::core::result::Result::Ok(__Field::__F5),
                            "is_im_infrastructure" => ::core::result::Result::Ok(__Field::__F6),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_PROPERTY",
                                    __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::v1_1::bmm::core::bmm_property::BmmPropertyData<T>;
            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 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("BMM_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("type"),
                                );
                            }
                            __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("is_im_infrastructure"),
                                );
                            }
                            __s6 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_property::BmmPropertyData {
                    documentation: __s0.flatten(),
                    name: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                    is_mandatory: __s2.flatten(),
                    is_computed: __s3.flatten(),
                    r#type: __s4
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                    is_im_runtime: __s5.flatten(),
                    is_im_infrastructure: __s6.flatten(),
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_PROPERTY",
            __FIELDS,
            __Visitor(::core::marker::PhantomData),
        )
    }
}

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

impl<'de, T: ::serde::de::DeserializeOwned> ::serde::Deserialize<'de>
    for crate::v1_1::bmm::core::bmm_property::BmmProperty<T>
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_CONTAINER_PROPERTY", "BMM_PROPERTY"];
        struct __Visitor<T>(::core::marker::PhantomData<(T,)>);
        impl<'de, T: ::serde::de::DeserializeOwned> ::serde::de::Visitor<'de> for __Visitor<T> {
            type Value = crate::v1_1::bmm::core::bmm_property::BmmProperty<T>;
            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::v1_1::bmm::core::bmm_property::BmmProperty::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_property::BmmProperty::BmmProperty(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_PROPERTY", __other, "BMM_CONTAINER_PROPERTY, BMM_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_PROPERTY",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(
                            crate::v1_1::bmm::core::bmm_property::BmmProperty::BmmProperty(
                                ::serde::Deserialize::deserialize(__rest)?,
                            ),
                        )
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(
            __deserializer,
            __Visitor(::core::marker::PhantomData),
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::bmm::core::bmm_schema_core::BmmSchemaCore {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["BMM_MODEL", "BMM_SCHEMA_CORE", "P_BMM_SCHEMA"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::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_MODEL" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_schema_core::BmmSchemaCore::BmmModel(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SCHEMA_CORE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_schema_core::BmmSchemaCore::BmmSchemaCore(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SCHEMA" => ::core::result::Result::Ok(crate::v1_1::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_MODEL, 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_MODEL, BMM_SCHEMA_CORE, P_BMM_SCHEMA",
                        ))
                    }
                    None => {
                        let __rest =
                            ::openehr_base::serde_support::TaggedRest::new(None, __buffered, __map);
                        ::core::result::Result::Ok(
                            crate::v1_1::bmm::core::bmm_schema_core::BmmSchemaCore::BmmSchemaCore(
                                ::serde::Deserialize::deserialize(__rest)?,
                            ),
                        )
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_1::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.documentation.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.documentation {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "documentation", __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::v1_1::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", "documentation"];
        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),
                            "documentation" => ::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::v1_1::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("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("base_class"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_simple_type::BmmSimpleType {
                    documentation: __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::v1_1::bmm::core::bmm_type::BmmType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm::core::bmm_type::BmmType::BmmContainerType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_type::BmmType::BmmGenericType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_type::BmmType::BmmOpenType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm::core::bmm_type::BmmType::BmmSimpleType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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_GENERIC_TYPE",
            "BMM_INDEXED_CONTAINER_TYPE",
            "BMM_OPEN_TYPE",
            "BMM_SIMPLE_TYPE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::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::v1_1::bmm::core::bmm_type::BmmType::BmmContainerType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_GENERIC_TYPE" => ::core::result::Result::Ok(
                                crate::v1_1::bmm::core::bmm_type::BmmType::BmmGenericType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(
                                crate::v1_1::bmm::core::bmm_type::BmmType::BmmContainerType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_OPEN_TYPE" => ::core::result::Result::Ok(
                                crate::v1_1::bmm::core::bmm_type::BmmType::BmmOpenType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(
                                crate::v1_1::bmm::core::bmm_type::BmmType::BmmSimpleType(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            __other => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unexpected_type(
                                    "BMM_TYPE",
                                    __other,
                                    "BMM_CONTAINER_TYPE, BMM_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_OPEN_TYPE, BMM_SIMPLE_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_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_OPEN_TYPE, BMM_SIMPLE_TYPE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_TYPE",
                            "BMM_CONTAINER_TYPE, BMM_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_OPEN_TYPE, BMM_SIMPLE_TYPE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::bmm::core::bmm_type_element::BmmTypeElement {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "BMM_CONTAINER_TYPE",
            "BMM_GENERIC_PARAMETER",
            "BMM_GENERIC_TYPE",
            "BMM_INDEXED_CONTAINER_TYPE",
            "BMM_OPEN_TYPE",
            "BMM_SIMPLE_TYPE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::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_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_type_element::BmmTypeElement::BmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_PARAMETER" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_type_element::BmmTypeElement::BmmGenericParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_type_element::BmmTypeElement::BmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_type_element::BmmTypeElement::BmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_OPEN_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_type_element::BmmTypeElement::BmmOpenType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm::core::bmm_type_element::BmmTypeElement::BmmSimpleType(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("BMM_TYPE_ELEMENT", __other, "BMM_CONTAINER_TYPE, BMM_GENERIC_PARAMETER, BMM_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_OPEN_TYPE, BMM_SIMPLE_TYPE")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "BMM_TYPE_ELEMENT",
                            &__other,
                            "BMM_CONTAINER_TYPE, BMM_GENERIC_PARAMETER, BMM_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_OPEN_TYPE, BMM_SIMPLE_TYPE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "BMM_TYPE_ELEMENT",
                            "BMM_CONTAINER_TYPE, BMM_GENERIC_PARAMETER, BMM_GENERIC_TYPE, BMM_INDEXED_CONTAINER_TYPE, BMM_OPEN_TYPE, BMM_SIMPLE_TYPE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::beom::core::expression::Expression {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "EXPR_BINARY_OPERATOR",
            "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::v1_1::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_BINARY_OPERATOR" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::expression::Expression::ExprBinaryOperator(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_FOR_ALL" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::expression::Expression::ExprForAll(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_FUNCTION_CALL" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::expression::Expression::ExprFunctionCall(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_LITERAL" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::expression::Expression::ExprLiteral(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_UNARY_OPERATOR" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::expression::Expression::ExprUnaryOperator(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_VALUE_REF" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::expression::Expression::ExprValueRef(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_VARIABLE_REF" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::expression::Expression::ExprVariableRef(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            __other => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unexpected_type(
                                    "EXPRESSION",
                                    __other,
                                    "EXPR_BINARY_OPERATOR, 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_BINARY_OPERATOR, 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_BINARY_OPERATOR, 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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::beom::core::expr_leaf::ExprLeaf {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::beom::core::expr_leaf::ExprLeaf::ExprFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::beom::core::expr_leaf::ExprLeaf::ExprLiteral(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::beom::core::expr_leaf::ExprLeaf::ExprValueRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::beom::core::expr_leaf::ExprLeaf::ExprVariableRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::beom::core::expr_leaf::ExprLeaf {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "EXPR_FUNCTION_CALL",
            "EXPR_LITERAL",
            "EXPR_VALUE_REF",
            "EXPR_VARIABLE_REF",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::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_FUNCTION_CALL" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::expr_leaf::ExprLeaf::ExprFunctionCall(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_LITERAL" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::expr_leaf::ExprLeaf::ExprLiteral(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_VALUE_REF" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::expr_leaf::ExprLeaf::ExprValueRef(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_VARIABLE_REF" => ::core::result::Result::Ok(
                                crate::v1_1::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_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_FUNCTION_CALL, EXPR_LITERAL, EXPR_VALUE_REF, EXPR_VARIABLE_REF",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EXPR_LEAF",
                            "EXPR_FUNCTION_CALL, EXPR_LITERAL, EXPR_VALUE_REF, EXPR_VARIABLE_REF",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_1::beom::core::expr_literal::ExprLiteral {
    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_LITERAL", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EXPR_LITERAL")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item", &self.item)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::beom::core::expr_literal::ExprLiteral {
    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_LITERAL",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::beom::core::expr_literal::ExprLiteral;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_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("EXPR_LITERAL"),
                            )?;
                        }
                        __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::v1_1::beom::core::expr_literal::ExprLiteral {
                    item: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("item"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EXPR_LITERAL",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::beom::core::expr_operator::ExprOperator::ExprBinaryOperator(::serde::Deserialize::deserialize(__rest)?)),
"EXPR_FOR_ALL" => ::core::result::Result::Ok(crate::v1_1::beom::core::expr_operator::ExprOperator::ExprForAll(::serde::Deserialize::deserialize(__rest)?)),
"EXPR_UNARY_OPERATOR" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::beom::types::expr_type_def::ExprTypeDef {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefBoolean(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefDate(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefDateTime(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefDuration(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefInteger(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefObjectRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefReal(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefString(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefTerminologyCode(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefTime(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefUri(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::beom::types::expr_type_def::ExprTypeDef {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "TYPE_DEF_BOOLEAN",
            "TYPE_DEF_DATE",
            "TYPE_DEF_DATE_TIME",
            "TYPE_DEF_DURATION",
            "TYPE_DEF_INTEGER",
            "TYPE_DEF_OBJECT_REF",
            "TYPE_DEF_REAL",
            "TYPE_DEF_STRING",
            "TYPE_DEF_TERMINOLOGY_CODE",
            "TYPE_DEF_TIME",
            "TYPE_DEF_URI",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::beom::types::expr_type_def::ExprTypeDef;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_TYPE_DEF` 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 {
"TYPE_DEF_BOOLEAN" => ::core::result::Result::Ok(crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefBoolean(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_DATE" => ::core::result::Result::Ok(crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefDate(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_DATE_TIME" => ::core::result::Result::Ok(crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefDateTime(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_DURATION" => ::core::result::Result::Ok(crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefDuration(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_INTEGER" => ::core::result::Result::Ok(crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefInteger(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_OBJECT_REF" => ::core::result::Result::Ok(crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefObjectRef(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_REAL" => ::core::result::Result::Ok(crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefReal(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_STRING" => ::core::result::Result::Ok(crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefString(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_TERMINOLOGY_CODE" => ::core::result::Result::Ok(crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefTerminologyCode(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_TIME" => ::core::result::Result::Ok(crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefTime(::serde::Deserialize::deserialize(__rest)?)),
"TYPE_DEF_URI" => ::core::result::Result::Ok(crate::v1_1::beom::types::expr_type_def::ExprTypeDef::TypeDefUri(::serde::Deserialize::deserialize(__rest)?)),
__other => ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type("EXPR_TYPE_DEF", __other, "TYPE_DEF_BOOLEAN, TYPE_DEF_DATE, TYPE_DEF_DATE_TIME, TYPE_DEF_DURATION, TYPE_DEF_INTEGER, TYPE_DEF_OBJECT_REF, TYPE_DEF_REAL, TYPE_DEF_STRING, TYPE_DEF_TERMINOLOGY_CODE, TYPE_DEF_TIME, TYPE_DEF_URI")),
}
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "EXPR_TYPE_DEF",
                            &__other,
                            "TYPE_DEF_BOOLEAN, TYPE_DEF_DATE, TYPE_DEF_DATE_TIME, TYPE_DEF_DURATION, TYPE_DEF_INTEGER, TYPE_DEF_OBJECT_REF, TYPE_DEF_REAL, TYPE_DEF_STRING, TYPE_DEF_TERMINOLOGY_CODE, TYPE_DEF_TIME, TYPE_DEF_URI",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "EXPR_TYPE_DEF",
                            "TYPE_DEF_BOOLEAN, TYPE_DEF_DATE, TYPE_DEF_DATE_TIME, TYPE_DEF_DURATION, TYPE_DEF_INTEGER, TYPE_DEF_OBJECT_REF, TYPE_DEF_REAL, TYPE_DEF_STRING, TYPE_DEF_TERMINOLOGY_CODE, TYPE_DEF_TIME, TYPE_DEF_URI",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::beom::core::expr_value::ExprValue {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "EXPR_BINARY_OPERATOR",
            "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::v1_1::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_BINARY_OPERATOR" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::expr_value::ExprValue::ExprBinaryOperator(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_FOR_ALL" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::expr_value::ExprValue::ExprForAll(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_FUNCTION_CALL" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::expr_value::ExprValue::ExprFunctionCall(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_LITERAL" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::expr_value::ExprValue::ExprLiteral(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_UNARY_OPERATOR" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::expr_value::ExprValue::ExprUnaryOperator(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_VALUE_REF" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::expr_value::ExprValue::ExprValueRef(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXPR_VARIABLE_REF" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::expr_value::ExprValue::ExprVariableRef(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EXTERNAL_QUERY" => ::core::result::Result::Ok(
                                crate::v1_1::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_BINARY_OPERATOR, 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_BINARY_OPERATOR, 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_BINARY_OPERATOR, 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::v1_1::beom::core::expr_value_ref::ExprValueRef {
    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::v1_1::beom::core::expr_value_ref::ExprValueRef {
    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::v1_1::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 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::v1_1::beom::core::expr_value_ref::ExprValueRef {
                    item: __s0.flatten(),
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EXPR_VALUE_REF",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::beom::core::expr_variable_ref::ExprVariableRef {
    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_VARIABLE_REF", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EXPR_VARIABLE_REF")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "item", &self.item)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::beom::core::expr_variable_ref::ExprVariableRef
{
    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_VARIABLE_REF",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::beom::core::expr_variable_ref::ExprVariableRef;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXPR_VARIABLE_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_VARIABLE_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::v1_1::beom::core::expr_variable_ref::ExprVariableRef {
                        item: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("item"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EXPR_VARIABLE_REF",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::beom::core::external_query::ExternalQuery {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 3usize;
        if self.query_args.as_ref().is_some_and(|__v| !__v.is_empty()) {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "EXTERNAL_QUERY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "EXTERNAL_QUERY")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "context", &self.context)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "query_id", &self.query_id)?;
        if let Some(__v) = &self.query_args
            && !__v.is_empty()
        {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "query_args", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::beom::core::external_query::ExternalQuery {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["context", "query_args", "query_id"];
        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),
                            "context" => ::core::result::Result::Ok(__Field::__F0),
                            "query_id" => ::core::result::Result::Ok(__Field::__F1),
                            "query_args" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "EXTERNAL_QUERY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::beom::core::external_query::ExternalQuery;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `EXTERNAL_QUERY` 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("EXTERNAL_QUERY"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("context"),
                                );
                            }
                            __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("query_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("query_args"),
                                );
                            }
                            __s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_1::beom::core::external_query::ExternalQuery {
                    context: __s0
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("context"))?,
                    query_id: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("query_id"))?,
                    query_args: __s2,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "EXTERNAL_QUERY",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::beom::core::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_1::beom::core::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_1::beom::core::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_1::beom::core::operator_kind::OperatorKind::from_wire(__v),
                )
            }
        }
        ::serde::Deserializer::deserialize_str(__deserializer, __V)
    }
}

impl ::serde::Serialize for crate::v1_1::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::v1_1::bmm_persistence::p_bmm_base_type::PBmmBaseType::PBmmGenericType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm_persistence::p_bmm_base_type::PBmmBaseType::PBmmOpenType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm_persistence::p_bmm_base_type::PBmmBaseType::PBmmSimpleType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm_persistence::p_bmm_base_type::PBmmBaseType::PBmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_OPEN_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_base_type::PBmmBaseType::PBmmOpenType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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.is_some() {
            __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 {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "ancestor_defs", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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<::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::v1_1::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.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_CLASS",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::bmm_persistence::p_bmm_class::PBmmClass::PBmmClass(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_class::PBmmClass::PBmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_class::PBmmClass::PBmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_class::PBmmClass::PBmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INTERFACE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm_persistence::p_bmm_class::PBmmClass::PBmmClass(
                                ::serde::Deserialize::deserialize(__rest)?,
                            ),
                        )
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_1::bmm_persistence::p_bmm_constant::PBmmConstant {
    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.value.is_some() {
            __n += 1;
        }
        let mut __st = ::serde::Serializer::serialize_struct(__serializer, "P_BMM_CONSTANT", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_BMM_CONSTANT")?;
        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)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        if let Some(__v) = &self.value {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "value", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::bmm_persistence::p_bmm_constant::PBmmConstant {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["documentation", "name", "type", "value"];
        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),
                            "type" => ::core::result::Result::Ok(__Field::__F2),
                            "value" => ::core::result::Result::Ok(__Field::__F3),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "P_BMM_CONSTANT",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::bmm_persistence::p_bmm_constant::PBmmConstant;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_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;
                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_CONSTANT"),
                            )?;
                        }
                        __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("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("value"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm_persistence::p_bmm_constant::PBmmConstant {
                        documentation: __s0.flatten(),
                        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"))?,
                        value: __s3.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_CONSTANT",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm_persistence::p_bmm_container_property::PBmmContainerProperty::PBmmIndexedContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_container_property::PBmmContainerProperty::PBmmContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm_persistence::p_bmm_container_property::PBmmContainerProperty::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm_persistence::p_bmm_container_property::PBmmContainerProperty::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm_persistence::p_bmm_container_type::PBmmContainerType::PBmmIndexedContainerType(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_container_type::PBmmContainerType::PBmmContainerType(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm_persistence::p_bmm_container_type::PBmmContainerType::PBmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm_persistence::p_bmm_container_type::PBmmContainerType::PBmmContainerType(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_1::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.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;
        }
        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 {
            ::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::v1_1::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::v1_1::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<::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::v1_1::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.flatten(),
                        item_names: __s14,
                        item_values: __s15,
                        item_documentations: __s16,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_ENUMERATION",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm_persistence::p_bmm_enumeration::PBmmEnumeration::PBmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_enumeration::PBmmEnumeration::PBmmEnumerationInteger(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm_persistence::p_bmm_enumeration::PBmmEnumeration::PBmmEnumeration(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_1::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.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;
        }
        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 {
            ::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::v1_1::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::v1_1::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<::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::v1_1::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.flatten(),
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::v1_1::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.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;
        }
        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 {
            ::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::v1_1::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::v1_1::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<::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::v1_1::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.flatten(),
                        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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter::PBmmContainerFunctionParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter::PBmmGenericFunctionParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter::PBmmSingleFunctionParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter::PBmmSingleFunctionParameterOpen(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter::PBmmContainerFunctionParameter(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_GENERIC_FUNCTION_PARAMETER" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter::PBmmGenericFunctionParameter(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_FUNCTION_PARAMETER" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_function_parameter::PBmmFunctionParameter::PBmmSingleFunctionParameter(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_FUNCTION_PARAMETER_OPEN" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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_some() {
            __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 let Some(__v) = &self.generic_parameter_defs {
            ::serde::ser::SerializeStruct::serialize_field(
                &mut __st,
                "generic_parameter_defs",
                __v,
            )?;
        }
        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::v1_1::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::v1_1::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<::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::v1_1::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.flatten(),
                        generic_parameters: __s4,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_GENERIC_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmClass(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmConstant(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmContainerFunctionParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmFunction(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmGenericFunctionParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmGenericParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmGenericProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmPackage(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSingleFunctionParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSingleFunctionParameterOpen(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSingleProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSinglePropertyOpen(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmClass(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_CONSTANT" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmConstant(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_CONTAINER_FUNCTION_PARAMETER" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmContainerFunctionParameter(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmClass(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmClass(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmClass(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_FUNCTION" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmFunction(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_GENERIC_FUNCTION_PARAMETER" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmGenericFunctionParameter(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_GENERIC_PARAMETER" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmGenericParameter(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_GENERIC_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmGenericProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INTERFACE" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmClass(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_PACKAGE" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmPackage(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_FUNCTION_PARAMETER" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSingleFunctionParameter(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_FUNCTION_PARAMETER_OPEN" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSingleFunctionParameterOpen(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_model_element::PBmmModelElement::PBmmSingleProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_PROPERTY_OPEN" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm_persistence::p_bmm_package::PBmmPackage {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if !self.packages.is_empty() {
            __n += 1;
        }
        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")?;
        if !self.packages.is_empty() {
            ::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::v1_1::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::v1_1::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<_> = 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::v1_1::bmm_persistence::p_bmm_package::PBmmPackage {
                        packages: __s0.unwrap_or_default(),
                        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::v1_1::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 = 1usize;
        if !self.packages.is_empty() {
            __n += 1;
        }
        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",
        )?;
        if !self.packages.is_empty() {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "packages", &self.packages)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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<_> = 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::v1_1::bmm_persistence::p_bmm_package_container::PBmmPackageContainerData {
packages: __s0.unwrap_or_default(),
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_PACKAGE_CONTAINER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_1::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::v1_1::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmPackage(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmSchema(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmPackageContainer(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmPackage(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_PACKAGE_CONTAINER" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmPackageContainer(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SCHEMA" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm_persistence::p_bmm_package_container::PBmmPackageContainer::PBmmPackageContainer(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::bmm_persistence::p_bmm_property::PBmmProperty::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_GENERIC_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_property::PBmmProperty::PBmmGenericProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_property::PBmmProperty::PBmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_property::PBmmProperty::PBmmSingleProperty(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SINGLE_PROPERTY_OPEN" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm_persistence::p_bmm_schema::PBmmSchema {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 9usize;
        if !self.packages.is_empty() {
            __n += 1;
        }
        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.is_some() {
            __n += 1;
        }
        if self.class_definitions.is_some() {
            __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")?;
        if !self.packages.is_empty() {
            ::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 {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "primitive_types", __v)?;
        }
        if let Some(__v) = &self.class_definitions {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "class_definitions", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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<_> = 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<::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_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::v1_1::bmm_persistence::p_bmm_schema::PBmmSchema {
                    packages: __s0.unwrap_or_default(),
                    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.flatten(),
                    class_definitions: __s16.flatten(),
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_SCHEMA",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm_persistence::p_bmm_single_function_parameter::PBmmSingleFunctionParameter
{
    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_SINGLE_FUNCTION_PARAMETER",
            __n,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "P_BMM_SINGLE_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", &self.r#type)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm_persistence::p_bmm_single_function_parameter::PBmmSingleFunctionParameter
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["documentation", "is_nullable", "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),
                            "documentation" => ::core::result::Result::Ok(__Field::__F0),
                            "name" => ::core::result::Result::Ok(__Field::__F1),
                            "is_nullable" => ::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_SINGLE_FUNCTION_PARAMETER",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::bmm_persistence::p_bmm_single_function_parameter::PBmmSingleFunctionParameter;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `P_BMM_SINGLE_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_SINGLE_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"),
                                );
                            }
                            __s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_single_function_parameter::PBmmSingleFunctionParameter {
documentation: __s0.flatten(),
name: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
is_nullable: __s2.flatten(),
r#type: __s3.flatten().ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "P_BMM_SINGLE_FUNCTION_PARAMETER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::bmm_persistence::p_bmm_single_function_parameter_open::PBmmSingleFunctionParameterOpen {
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_SINGLE_FUNCTION_PARAMETER_OPEN", __n)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "P_BMM_SINGLE_FUNCTION_PARAMETER_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_nullable { ::serde::ser::SerializeStruct::serialize_field(&mut __st, "is_nullable", __v)?; }
::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
::serde::ser::SerializeStruct::end(__st)
}
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::bmm_persistence::p_bmm_single_function_parameter_open::PBmmSingleFunctionParameterOpen {
fn deserialize<__D: ::serde::Deserializer<'de>>(__deserializer: __D) -> ::core::result::Result<Self, __D::Error> {
const __FIELDS: &[&str] = &["documentation", "is_nullable", "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),
"documentation" => ::core::result::Result::Ok(__Field::__F0),
"name" => ::core::result::Result::Ok(__Field::__F1),
"is_nullable" => ::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_SINGLE_FUNCTION_PARAMETER_OPEN", __FIELDS)),
}
}
}
::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
}
}
struct __Visitor;
impl<'de> ::serde::de::Visitor<'de> for __Visitor {
type Value = crate::v1_1::bmm_persistence::p_bmm_single_function_parameter_open::PBmmSingleFunctionParameterOpen;
fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
__f.write_str("an openEHR `P_BMM_SINGLE_FUNCTION_PARAMETER_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;
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_FUNCTION_PARAMETER_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_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")); }
__s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
}
}
::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_single_function_parameter_open::PBmmSingleFunctionParameterOpen {
documentation: __s0.flatten(),
name: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
is_nullable: __s2.flatten(),
r#type: __s3.flatten().ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
})
}
}
::serde::Deserializer::deserialize_struct(__deserializer, "P_BMM_SINGLE_FUNCTION_PARAMETER_OPEN", __FIELDS, __Visitor)
}
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::bmm_persistence::p_bmm_type::PBmmType::PBmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_GENERIC_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_type::PBmmType::PBmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_type::PBmmType::PBmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_OPEN_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm_persistence::p_bmm_type::PBmmType::PBmmOpenType(::serde::Deserialize::deserialize(__rest)?)),
"P_BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm::rm_access::schema_descriptor::SchemaDescriptor {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_1::bmm::rm_access::schema_descriptor::SchemaDescriptor::PBmmSchemaDescriptor(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm::rm_access::schema_descriptor::SchemaDescriptor::SchemaDescriptor(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm::rm_access::schema_descriptor::SchemaDescriptor::PBmmSchemaDescriptor(::serde::Deserialize::deserialize(__rest)?)),
"SCHEMA_DESCRIPTOR" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm::rm_access::schema_descriptor::SchemaDescriptor::SchemaDescriptor(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::beom::core::statement::Statement::Assertion(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "ASSIGNMENT" => ::core::result::Result::Ok(
                                crate::v1_1::beom::core::statement::Statement::Assignment(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "VARIABLE_DECLARATION" => ::core::result::Result::Ok(
                                crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::beom::core::statement_set::StatementSet {
                    statement: __s0,
                    name: __s1.flatten(),
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "STATEMENT_SET",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::beom::types::type_def_boolean::TypeDefBoolean {
    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, "TYPE_DEF_BOOLEAN", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_BOOLEAN")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::beom::types::type_def_boolean::TypeDefBoolean {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_BOOLEAN",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::beom::types::type_def_boolean::TypeDefBoolean;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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("TYPE_DEF_BOOLEAN"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::beom::types::type_def_boolean::TypeDefBoolean {
                        type_name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("Boolean")),
                        type_anchor: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_BOOLEAN",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::beom::types::type_def_date::TypeDefDate {
    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, "TYPE_DEF_DATE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_DATE")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::beom::types::type_def_date::TypeDefDate {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_DATE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::beom::types::type_def_date::TypeDefDate;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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("TYPE_DEF_DATE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_1::beom::types::type_def_date::TypeDefDate {
                    type_name: __s0
                        .flatten()
                        .unwrap_or(::std::string::String::from("Date")),
                    type_anchor: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_DATE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::beom::types::type_def_date_time::TypeDefDateTime {
    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, "TYPE_DEF_DATE_TIME", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_DATE_TIME")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::beom::types::type_def_date_time::TypeDefDateTime
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_DATE_TIME",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::beom::types::type_def_date_time::TypeDefDateTime;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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("TYPE_DEF_DATE_TIME"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::beom::types::type_def_date_time::TypeDefDateTime {
                        type_name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("Date_time")),
                        type_anchor: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_DATE_TIME",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::beom::types::type_def_duration::TypeDefDuration {
    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, "TYPE_DEF_DURATION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_DURATION")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::beom::types::type_def_duration::TypeDefDuration
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_DURATION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::beom::types::type_def_duration::TypeDefDuration;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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("TYPE_DEF_DURATION"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::beom::types::type_def_duration::TypeDefDuration {
                        type_name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("Duration")),
                        type_anchor: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_DURATION",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::beom::types::type_def_integer::TypeDefInteger {
    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, "TYPE_DEF_INTEGER", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_INTEGER")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::beom::types::type_def_integer::TypeDefInteger {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_INTEGER",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::beom::types::type_def_integer::TypeDefInteger;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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("TYPE_DEF_INTEGER"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::beom::types::type_def_integer::TypeDefInteger {
                        type_name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("Integer")),
                        type_anchor: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_INTEGER",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::beom::types::type_def_object_ref::TypeDefObjectRef {
    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, "TYPE_DEF_OBJECT_REF", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_OBJECT_REF")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::beom::types::type_def_object_ref::TypeDefObjectRef
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_OBJECT_REF",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::beom::types::type_def_object_ref::TypeDefObjectRef;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_OBJECT_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("TYPE_DEF_OBJECT_REF"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::beom::types::type_def_object_ref::TypeDefObjectRef {
                        type_name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("Object_ref")),
                        type_anchor: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_OBJECT_REF",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::beom::types::type_def_real::TypeDefReal {
    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, "TYPE_DEF_REAL", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_REAL")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::beom::types::type_def_real::TypeDefReal {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_REAL",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::beom::types::type_def_real::TypeDefReal;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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("TYPE_DEF_REAL"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_1::beom::types::type_def_real::TypeDefReal {
                    type_name: __s0
                        .flatten()
                        .unwrap_or(::std::string::String::from("Real")),
                    type_anchor: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_REAL",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::beom::types::type_def_string::TypeDefString {
    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, "TYPE_DEF_STRING", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_STRING")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::beom::types::type_def_string::TypeDefString {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_STRING",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::beom::types::type_def_string::TypeDefString;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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("TYPE_DEF_STRING"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::beom::types::type_def_string::TypeDefString {
                        type_name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("String")),
                        type_anchor: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_STRING",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_1::beom::types::type_def_terminology_code::TypeDefTerminologyCode
{
    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, "TYPE_DEF_TERMINOLOGY_CODE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "TYPE_DEF_TERMINOLOGY_CODE",
        )?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::beom::types::type_def_terminology_code::TypeDefTerminologyCode
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_TERMINOLOGY_CODE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_1::beom::types::type_def_terminology_code::TypeDefTerminologyCode;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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(
                                    "TYPE_DEF_TERMINOLOGY_CODE",
                                ),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::beom::types::type_def_terminology_code::TypeDefTerminologyCode {
                        type_name: __s0
                            .flatten()
                            .unwrap_or(::std::string::String::from("Terminology_code")),
                        type_anchor: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_TERMINOLOGY_CODE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::beom::types::type_def_time::TypeDefTime {
    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, "TYPE_DEF_TIME", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_TIME")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::beom::types::type_def_time::TypeDefTime {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_TIME",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::beom::types::type_def_time::TypeDefTime;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_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;
                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("TYPE_DEF_TIME"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_1::beom::types::type_def_time::TypeDefTime {
                    type_name: __s0
                        .flatten()
                        .unwrap_or(::std::string::String::from("Time")),
                    type_anchor: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_TIME",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::beom::types::type_def_uri::TypeDefUri {
    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, "TYPE_DEF_URI", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TYPE_DEF_URI")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type_name", &self.type_name)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "type_anchor",
            &self.type_anchor,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::beom::types::type_def_uri::TypeDefUri {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["type_anchor", "type_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),
                            "type_name" => ::core::result::Result::Ok(__Field::__F0),
                            "type_anchor" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "TYPE_DEF_URI",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::beom::types::type_def_uri::TypeDefUri;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `TYPE_DEF_URI` 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("TYPE_DEF_URI"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("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("type_anchor"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_1::beom::types::type_def_uri::TypeDefUri {
                    type_name: __s0.flatten().unwrap_or(::std::string::String::from("Uri")),
                    type_anchor: __s1
                        .flatten()
                        .ok_or_else(|| ::serde::de::Error::missing_field("type_anchor"))?,
                })
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "TYPE_DEF_URI",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::beom::core::variable_declaration::VariableDeclaration {
    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, "VARIABLE_DECLARATION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "VARIABLE_DECLARATION")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "type", &self.r#type)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::beom::core::variable_declaration::VariableDeclaration
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["name", "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),
                            "name" => ::core::result::Result::Ok(__Field::__F0),
                            "type" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "VARIABLE_DECLARATION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::beom::core::variable_declaration::VariableDeclaration;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `VARIABLE_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;
                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("VARIABLE_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("type"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::beom::core::variable_declaration::VariableDeclaration {
                        name: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                        r#type: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("type"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "VARIABLE_DECLARATION",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_1::bmm3::statement::bmm_action_decision_table::BmmActionDecisionTable
{
    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_ACTION_DECISION_TABLE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "BMM_ACTION_DECISION_TABLE",
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm3::statement::bmm_action_decision_table::BmmActionDecisionTable
{
    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_ACTION_DECISION_TABLE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_1::bmm3::statement::bmm_action_decision_table::BmmActionDecisionTable;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_ACTION_DECISION_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;
                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_ACTION_DECISION_TABLE",
                                ),
                            )?;
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_1::bmm3::statement::bmm_action_decision_table::BmmActionDecisionTable {
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_ACTION_DECISION_TABLE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::bmm3::statement::bmm_action_table::BmmActionTable {
    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_ACTION_TABLE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_ACTION_TABLE")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "decision_table",
            &self.decision_table,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm3::statement::bmm_action_table::BmmActionTable
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["decision_table"];
        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),
                            "decision_table" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_ACTION_TABLE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::bmm3::statement::bmm_action_table::BmmActionTable;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_ACTION_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;
                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_ACTION_TABLE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("decision_table"),
                                );
                            }
                            __s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm3::statement::bmm_action_table::BmmActionTable {
                        decision_table: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("decision_table"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_ACTION_TABLE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmSignature(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_1::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmStatusType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_1::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmTupleType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROPERTY_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ROUTINE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIGNATURE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STATUS_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_builtin_type::BmmBuiltinType::BmmStatusType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_TUPLE_TYPE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::core::entity::bmm_class::BmmClass {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::core::entity::bmm_class::BmmClass::BmmGenericClass(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::entity::bmm_class::BmmClass::BmmSimpleClass(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::bmm_class::BmmClass::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_class::BmmClass::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_class::BmmClass::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_CLASS" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_class::BmmClass::BmmGenericClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_CLASS" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::core::feature::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::v1_1::bmm3::core::feature::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::v1_1::bmm3::core::feature::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::v1_1::bmm3::core::feature::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::v1_1::bmm3::core::feature::bmm_container_property::BmmContainerProperty
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_1::bmm3::core::feature::bmm_container_property::BmmContainerProperty::BmmIndexedContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::feature::bmm_container_property::BmmContainerProperty::BmmContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm3::core::feature::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::v1_1::bmm3::core::feature::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::v1_1::bmm3::core::feature::bmm_container_property::BmmContainerProperty::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::feature::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::v1_1::bmm3::core::feature::bmm_container_property::BmmContainerProperty::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::bmm_container_type::BmmContainerType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_1::bmm3::core::entity::bmm_container_type::BmmContainerType::BmmIndexedContainerType(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::entity::bmm_container_type::BmmContainerType::BmmContainerType(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::bmm_container_type::BmmContainerType::BmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::bmm_container_type::BmmContainerType::BmmContainerType(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize
    for crate::v1_1::bmm3::core::literal_value::bmm_container_value::BmmContainerValue
{
    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_CONTAINER_VALUE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_CONTAINER_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::v1_1::bmm3::core::literal_value::bmm_container_value::BmmContainerValue
{
    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_CONTAINER_VALUE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_1::bmm3::core::literal_value::bmm_container_value::BmmContainerValue;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_CONTAINER_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_CONTAINER_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::v1_1::bmm3::core::literal_value::bmm_container_value::BmmContainerValue {
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_CONTAINER_VALUE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::bmm_definitions::BmmDefinitions {
    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::v1_1::bmm3::bmm_definitions::BmmDefinitions {
    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::v1_1::bmm3::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 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::v1_1::bmm3::bmm_definitions::BmmDefinitions {})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_DEFINITIONS",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::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::v1_1::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmGenericType(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmSignature(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmSimpleType(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmStatusType(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmTupleType(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROPERTY_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ROUTINE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIGNATURE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmSimpleType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STATUS_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_effective_type::BmmEffectiveType::BmmStatusType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_TUPLE_TYPE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::core::entity::bmm_entity_metatype::BmmEntityMetatype
{
    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_1::bmm3::core::entity::bmm_entity_metatype::BmmEntityMetatype
{
    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_1::bmm3::core::entity::bmm_entity_metatype::BmmEntityMetatype;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("a `BmmEntityMetatype` token")
            }
            fn visit_str<__E: ::serde::de::Error>(
                self,
                __v: &str,
            ) -> ::core::result::Result<Self::Value, __E> {
                ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_entity_metatype::BmmEntityMetatype::from_wire(__v))
            }
        }
        ::serde::Deserializer::deserialize_str(__deserializer, __V)
    }
}

impl ::serde::Serialize
    for crate::v1_1::bmm3::core::entity::range_constrained::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::v1_1::bmm3::core::entity::range_constrained::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::v1_1::bmm3::core::entity::range_constrained::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::v1_1::bmm3::core::entity::range_constrained::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::v1_1::bmm3::core::entity::range_constrained::bmm_enumeration::BmmEnumeration
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_1::bmm3::core::entity::range_constrained::bmm_enumeration::BmmEnumeration::BmmEnumerationInteger(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::entity::range_constrained::bmm_enumeration::BmmEnumeration::BmmEnumerationString(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::entity::range_constrained::bmm_enumeration::BmmEnumeration::BmmEnumeration(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm3::core::entity::range_constrained::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::v1_1::bmm3::core::entity::range_constrained::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::v1_1::bmm3::core::entity::range_constrained::bmm_enumeration::BmmEnumeration::BmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::range_constrained::bmm_enumeration::BmmEnumeration::BmmEnumerationInteger(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::range_constrained::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::v1_1::bmm3::core::entity::range_constrained::bmm_enumeration::BmmEnumeration::BmmEnumeration(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_1::bmm3::core::entity::range_constrained::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::v1_1::bmm3::core::entity::range_constrained::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::v1_1::bmm3::core::entity::range_constrained::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::v1_1::bmm3::core::entity::range_constrained::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::v1_1::bmm3::core::entity::range_constrained::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::v1_1::bmm3::core::entity::range_constrained::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::v1_1::bmm3::core::entity::range_constrained::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::v1_1::bmm3::core::entity::range_constrained::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::v1_1::bmm3::core::feature::bmm_external_routine::BmmExternalRoutine
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        let mut __n = 2usize;
        if self.argument_mapping.is_some() {
            __n += 1;
        }
        let mut __st =
            ::serde::Serializer::serialize_struct(__serializer, "BMM_EXTERNAL_ROUTINE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_EXTERNAL_ROUTINE")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "meta_data", &self.meta_data)?;
        if let Some(__v) = &self.argument_mapping {
            ::serde::ser::SerializeStruct::serialize_field(&mut __st, "argument_mapping", __v)?;
        }
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm3::core::feature::bmm_external_routine::BmmExternalRoutine
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["argument_mapping", "meta_data"];
        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),
                            "meta_data" => ::core::result::Result::Ok(__Field::__F0),
                            "argument_mapping" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_EXTERNAL_ROUTINE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::bmm3::core::feature::bmm_external_routine::BmmExternalRoutine;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_EXTERNAL_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<::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_EXTERNAL_ROUTINE"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("meta_data"),
                                );
                            }
                            __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_mapping"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm3::core::feature::bmm_external_routine::BmmExternalRoutine {
                        meta_data: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("meta_data"))?,
                        argument_mapping: __s1.flatten(),
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_EXTERNAL_ROUTINE",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::feature::bmm_feature::BmmFeature::BmmConstant(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::feature::bmm_feature::BmmFeature::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_FUNCTION" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::feature::bmm_feature::BmmFeature::BmmFunction(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::feature::bmm_feature::BmmFeature::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::feature::bmm_feature::BmmFeature::BmmProcedure(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SINGLETON" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::feature::bmm_feature::BmmFeature::BmmSingleton(::serde::Deserialize::deserialize(__rest)?)),
"BMM_UNITARY_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::core::feature::bmm_feature_extension::BmmFeatureExtension
{
    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_FEATURE_EXTENSION", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "_type",
            "BMM_FEATURE_EXTENSION",
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm3::core::feature::bmm_feature_extension::BmmFeatureExtension
{
    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_FEATURE_EXTENSION",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_1::bmm3::core::feature::bmm_feature_extension::BmmFeatureExtension;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_FEATURE_EXTENSION` 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_FEATURE_EXTENSION",
                                ),
                            )?;
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm3::core::feature::bmm_feature_extension::BmmFeatureExtension {},
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_FEATURE_EXTENSION",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::bmm_formal_element::BmmFormalElement::BmmConstant(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_formal_element::BmmFormalElement::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_FUNCTION" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_formal_element::BmmFormalElement::BmmFunction(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_formal_element::BmmFormalElement::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_LOCAL" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_formal_element::BmmFormalElement::BmmLocal(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PARAMETER" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_formal_element::BmmFormalElement::BmmParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_formal_element::BmmFormalElement::BmmProcedure(::serde::Deserialize::deserialize(__rest)?)),
"BMM_RESULT" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_formal_element::BmmFormalElement::BmmResult(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SELF" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_formal_element::BmmFormalElement::BmmSelf(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SINGLETON" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_formal_element::BmmFormalElement::BmmSingleton(::serde::Deserialize::deserialize(__rest)?)),
"BMM_UNITARY_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::model_access::bmm_include_spec::BmmIncludeSpec {
    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_INCLUDE_SPEC", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_INCLUDE_SPEC")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "id", &self.id)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm3::model_access::bmm_include_spec::BmmIncludeSpec
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["id"];
        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),
                            "id" => ::core::result::Result::Ok(__Field::__F0),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_INCLUDE_SPEC",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::bmm3::model_access::bmm_include_spec::BmmIncludeSpec;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_INCLUDE_SPEC` 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_INCLUDE_SPEC"),
                            )?;
                        }
                        __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)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm3::model_access::bmm_include_spec::BmmIncludeSpec {
                        id: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("id"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_INCLUDE_SPEC",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize for crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::literal_value::bmm_indexed_container_value::BmmIndexedContainerValue {
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_INDEXED_CONTAINER_VALUE", __n)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_INDEXED_CONTAINER_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::v1_1::bmm3::core::literal_value::bmm_indexed_container_value::BmmIndexedContainerValue {
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_INDEXED_CONTAINER_VALUE", __FIELDS)),
}
}
}
::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
}
}
struct __Visitor;
impl<'de> ::serde::de::Visitor<'de> for __Visitor {
type Value = crate::v1_1::bmm3::core::literal_value::bmm_indexed_container_value::BmmIndexedContainerValue;
fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
__f.write_str("an openEHR `BMM_INDEXED_CONTAINER_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_INDEXED_CONTAINER_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::v1_1::bmm3::core::literal_value::bmm_indexed_container_value::BmmIndexedContainerValue {
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_INDEXED_CONTAINER_VALUE", __FIELDS, __Visitor)
}
}

impl ::serde::Serialize
    for crate::v1_1::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::v1_1::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature::BmmConstant(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature::BmmContainerProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature::BmmSingleton(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature::BmmUnitaryProperty(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature::BmmConstant(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SINGLETON" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::feature::bmm_instantiable_feature::BmmInstantiableFeature::BmmSingleton(::serde::Deserialize::deserialize(__rest)?)),
"BMM_UNITARY_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::core::literal_value::bmm_interval_value::BmmIntervalValue
{
    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_INTERVAL_VALUE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_INTERVAL_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::v1_1::bmm3::core::literal_value::bmm_interval_value::BmmIntervalValue
{
    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_INTERVAL_VALUE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value =
                crate::v1_1::bmm3::core::literal_value::bmm_interval_value::BmmIntervalValue;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_INTERVAL_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_INTERVAL_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::v1_1::bmm3::core::literal_value::bmm_interval_value::BmmIntervalValue {
                        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_INTERVAL_VALUE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_1::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::v1_1::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmContainerValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmIndexedContainerValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmIntervalValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmPrimitiveValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_VALUE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmContainerValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_VALUE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmIndexedContainerValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INTEGER_VALUE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INTERVAL_VALUE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmIntervalValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PRIMITIVE_VALUE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::literal_value::bmm_literal_value::BmmLiteralValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STRING_VALUE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::core::model::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::v1_1::bmm3::core::model::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::v1_1::bmm3::core::model::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::v1_1::bmm3::core::model::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::core::bmm_model_element::BmmModelElement {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmConstant(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmContainerProperty(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmFunction(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmGenericClass(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmLocal(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmModel(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmPackage(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmParameter(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmProcedure(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmResult(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmSelf(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmSimpleClass(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmSingleton(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmUnitaryProperty(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm3::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_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::v1_1::bmm3::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::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmConstant(::serde::Deserialize::deserialize(__rest)?)),
"BMM_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_FUNCTION" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmFunction(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_CLASS" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmGenericClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_LOCAL" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmLocal(::serde::Deserialize::deserialize(__rest)?)),
"BMM_MODEL" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmModel(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PACKAGE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmPackage(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PARAMETER" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmProcedure(::serde::Deserialize::deserialize(__rest)?)),
"BMM_RESULT" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmResult(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SELF" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmSelf(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_CLASS" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SINGLETON" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::bmm_model_element::BmmModelElement::BmmSingleton(::serde::Deserialize::deserialize(__rest)?)),
"BMM_UNITARY_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm3::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_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_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_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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::core::model::bmm_model_metadata::BmmModelMetadata::BmmModel(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::model::bmm_model_metadata::BmmModelMetadata::BmmModelMetadata(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::model::bmm_model_metadata::BmmModelMetadata::BmmModel(::serde::Deserialize::deserialize(__rest)?)),
"BMM_MODEL_METADATA" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::core::model::bmm_model_metadata::BmmModelMetadata::BmmModelMetadata(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_1::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::v1_1::bmm3::core::entity::bmm_model_type::BmmModelType::BmmGenericType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::entity::bmm_model_type::BmmModelType::BmmSimpleType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::entity::bmm_model_type::BmmModelType::BmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::core::entity::bmm_module::BmmModule {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::core::entity::bmm_module::BmmModule::BmmGenericClass(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::entity::bmm_module::BmmModule::BmmSimpleClass(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::entity::bmm_module::BmmModule::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_module::BmmModule::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_module::BmmModule::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_CLASS" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_module::BmmModule::BmmGenericClass(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_CLASS" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::core::feature::bmm_operator::BmmOperator {
    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_OPERATOR", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_OPERATOR")?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "position", &self.position)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "symbols", &self.symbols)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm3::core::feature::bmm_operator::BmmOperator
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["name", "position", "symbols"];
        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),
                            "position" => ::core::result::Result::Ok(__Field::__F0),
                            "symbols" => ::core::result::Result::Ok(__Field::__F1),
                            "name" => ::core::result::Result::Ok(__Field::__F2),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_OPERATOR",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::bmm3::core::feature::bmm_operator::BmmOperator;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_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;
                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_OPERATOR"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("position"),
                                );
                            }
                            __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("symbols"),
                                );
                            }
                            __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)?);
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm3::core::feature::bmm_operator::BmmOperator {
                        position: __s0
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("position"))?,
                        symbols: __s1
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("symbols"))?,
                        name: __s2
                            .flatten()
                            .ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_OPERATOR",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_1::bmm3::core::feature::bmm_operator_position::BmmOperatorPosition
{
    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_1::bmm3::core::feature::bmm_operator_position::BmmOperatorPosition
{
    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_1::bmm3::core::feature::bmm_operator_position::BmmOperatorPosition;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("a `BmmOperatorPosition` token")
            }
            fn visit_str<__E: ::serde::de::Error>(
                self,
                __v: &str,
            ) -> ::core::result::Result<Self::Value, __E> {
                ::core::result::Result::Ok(crate::v1_1::bmm3::core::feature::bmm_operator_position::BmmOperatorPosition::from_wire(__v))
            }
        }
        ::serde::Deserializer::deserialize_str(__deserializer, __V)
    }
}

impl ::serde::Serialize for crate::v1_1::bmm3::core::model::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::v1_1::bmm3::core::model::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::v1_1::bmm3::core::model::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::v1_1::bmm3::core::model::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::v1_1::bmm3::core::model::bmm_package_container::BmmPackageContainer
{
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_1::bmm3::core::model::bmm_package_container::BmmPackageContainer::BmmModel(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::model::bmm_package_container::BmmPackageContainer::BmmPackage(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm3::core::model::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::v1_1::bmm3::core::model::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::v1_1::bmm3::core::model::bmm_package_container::BmmPackageContainer::BmmModel(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PACKAGE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::model::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::core::feature::bmm_parameter_direction::BmmParameterDirection
{
    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_1::bmm3::core::feature::bmm_parameter_direction::BmmParameterDirection
{
    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_1::bmm3::core::feature::bmm_parameter_direction::BmmParameterDirection;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("a `BmmParameterDirection` token")
            }
            fn visit_str<__E: ::serde::de::Error>(
                self,
                __v: &str,
            ) -> ::core::result::Result<Self::Value, __E> {
                ::core::result::Result::Ok(crate::v1_1::bmm3::core::feature::bmm_parameter_direction::BmmParameterDirection::from_wire(__v))
            }
        }
        ::serde::Deserializer::deserialize_str(__deserializer, __V)
    }
}

impl ::serde::Serialize for crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmBooleanValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmIntegerValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmStringValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmPrimitiveValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmBooleanValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INTEGER_VALUE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmIntegerValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PRIMITIVE_VALUE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STRING_VALUE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::core::literal_value::bmm_primitive_value::BmmPrimitiveValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::core::feature::bmm_property::BmmProperty {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::core::feature::bmm_property::BmmProperty::BmmContainerProperty(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_1::bmm3::core::feature::bmm_property::BmmProperty::BmmUnitaryProperty(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm3::core::feature::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::v1_1::bmm3::core::feature::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::v1_1::bmm3::core::feature::bmm_property::BmmProperty::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::feature::bmm_property::BmmProperty::BmmContainerProperty(::serde::Deserialize::deserialize(__rest)?)),
"BMM_UNITARY_PROPERTY" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::feature::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::core::feature::bmm_readonly_variable::BmmReadonlyVariable::BmmParameter(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::feature::bmm_readonly_variable::BmmReadonlyVariable::BmmSelf(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::feature::bmm_readonly_variable::BmmReadonlyVariable::BmmParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SELF" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::core::feature::bmm_routine::BmmRoutine {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::core::feature::bmm_routine::BmmRoutine::BmmFunction(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::feature::bmm_routine::BmmRoutine::BmmProcedure(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::feature::bmm_routine::BmmRoutine::BmmFunction(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::bmm3::core::feature::bmm_routine_definition::BmmRoutineDefinition::BmmExternalRoutine(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::feature::bmm_routine_definition::BmmRoutineDefinition::BmmLocalRoutine(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::feature::bmm_routine_definition::BmmRoutineDefinition::BmmExternalRoutine(::serde::Deserialize::deserialize(__rest)?)),
"BMM_LOCAL_ROUTINE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::core::entity::bmm_routine_type::BmmRoutineType::BmmFunctionType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_1::bmm3::core::entity::bmm_routine_type::BmmRoutineType::BmmProcedureType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_1::bmm3::core::entity::bmm_routine_type::BmmRoutineType::BmmRoutineType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::entity::bmm_routine_type::BmmRoutineType::BmmFunctionType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_routine_type::BmmRoutineType::BmmProcedureType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ROUTINE_TYPE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::core::entity::bmm_routine_type::BmmRoutineType::BmmRoutineType(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::model_access::bmm_schema_metadata_key::BmmSchemaMetadataKey
{
    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_1::bmm3::model_access::bmm_schema_metadata_key::BmmSchemaMetadataKey
{
    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_1::bmm3::model_access::bmm_schema_metadata_key::BmmSchemaMetadataKey;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("a `BmmSchemaMetadataKey` token")
            }
            fn visit_str<__E: ::serde::de::Error>(
                self,
                __v: &str,
            ) -> ::core::result::Result<Self::Value, __E> {
                ::core::result::Result::Ok(crate::v1_1::bmm3::model_access::bmm_schema_metadata_key::BmmSchemaMetadataKey::from_wire(__v))
            }
        }
        ::serde::Deserializer::deserialize_str(__deserializer, __V)
    }
}

impl ::serde::Serialize for crate::v1_1::bmm3::model_access::bmm_schema_state::BmmSchemaState {
    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_1::bmm3::model_access::bmm_schema_state::BmmSchemaState
{
    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_1::bmm3::model_access::bmm_schema_state::BmmSchemaState;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("a `BmmSchemaState` token")
            }
            fn visit_str<__E: ::serde::de::Error>(
                self,
                __v: &str,
            ) -> ::core::result::Result<Self::Value, __E> {
                ::core::result::Result::Ok(
                    crate::v1_1::bmm3::model_access::bmm_schema_state::BmmSchemaState::from_wire(
                        __v,
                    ),
                )
            }
        }
        ::serde::Deserializer::deserialize_str(__deserializer, __V)
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::entity::bmm_signature::BmmSignature::BmmRoutineType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_signature::BmmSignature::BmmRoutineType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROPERTY_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_signature::BmmSignature::BmmPropertyType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ROUTINE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_signature::BmmSignature::BmmRoutineType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIGNATURE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::core::entity::bmm_signature::BmmSignature::BmmSignature(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

impl ::serde::Serialize for crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::core::entity::bmm_simple_class::BmmSimpleClass::BmmEnumeration(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_1::bmm3::core::entity::bmm_simple_class::BmmSimpleClass::BmmSimpleClass(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::entity::bmm_simple_class::BmmSimpleClass::BmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_INTEGER" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_simple_class::BmmSimpleClass::BmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ENUMERATION_STRING" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_simple_class::BmmSimpleClass::BmmEnumeration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_CLASS" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::core::entity::bmm_simple_class::BmmSimpleClass::BmmSimpleClass(::serde::Deserialize::deserialize(__rest)?))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::statement::bmm_simple_statement::BmmSimpleStatement::BmmAssertion(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ASSIGNMENT" => ::core::result::Result::Ok(crate::v1_1::bmm3::statement::bmm_simple_statement::BmmSimpleStatement::BmmAssignment(::serde::Deserialize::deserialize(__rest)?)),
"BMM_DECLARATION" => ::core::result::Result::Ok(crate::v1_1::bmm3::statement::bmm_simple_statement::BmmSimpleStatement::BmmDeclaration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_CALL" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::statement::bmm_statement::BmmStatement {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::statement::bmm_statement::BmmStatement::BmmActionTable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::statement::bmm_statement::BmmStatement::BmmAssertion(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::statement::bmm_statement::BmmStatement::BmmAssignment(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::statement::bmm_statement::BmmStatement::BmmDeclaration(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::statement::bmm_statement::BmmStatement::BmmProcedureCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::bmm3::statement::bmm_statement::BmmStatement::BmmActionTable(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ASSERTION" => ::core::result::Result::Ok(crate::v1_1::bmm3::statement::bmm_statement::BmmStatement::BmmAssertion(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ASSIGNMENT" => ::core::result::Result::Ok(crate::v1_1::bmm3::statement::bmm_statement::BmmStatement::BmmAssignment(::serde::Deserialize::deserialize(__rest)?)),
"BMM_DECLARATION" => ::core::result::Result::Ok(crate::v1_1::bmm3::statement::bmm_statement::BmmStatement::BmmDeclaration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_CALL" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::statement::bmm_statement_block::BmmStatementBlock {
                        items: __s0,
                    },
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_STATEMENT_BLOCK",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::statement::bmm_statement_item::BmmStatementItem::BmmActionTable(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ASSERTION" => ::core::result::Result::Ok(crate::v1_1::bmm3::statement::bmm_statement_item::BmmStatementItem::BmmAssertion(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ASSIGNMENT" => ::core::result::Result::Ok(crate::v1_1::bmm3::statement::bmm_statement_item::BmmStatementItem::BmmAssignment(::serde::Deserialize::deserialize(__rest)?)),
"BMM_DECLARATION" => ::core::result::Result::Ok(crate::v1_1::bmm3::statement::bmm_statement_item::BmmStatementItem::BmmDeclaration(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_CALL" => ::core::result::Result::Ok(crate::v1_1::bmm3::statement::bmm_statement_item::BmmStatementItem::BmmProcedureCall(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STATEMENT_BLOCK" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::core::feature::bmm_static::BmmStatic {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::core::feature::bmm_static::BmmStatic::BmmConstant(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::feature::bmm_static::BmmStatic::BmmSingleton(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::feature::bmm_static::BmmStatic::BmmConstant(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SINGLETON" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::core::entity::bmm_status_type::BmmStatusType {
    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_STATUS_TYPE", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_STATUS_TYPE")?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm3::core::entity::bmm_status_type::BmmStatusType
{
    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_STATUS_TYPE",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::bmm3::core::entity::bmm_status_type::BmmStatusType;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_STATUS_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;
                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_STATUS_TYPE"),
                            )?;
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm3::core::entity::bmm_status_type::BmmStatusType {},
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_STATUS_TYPE",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::core::entity::bmm_type::BmmType {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmContainerType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmGenericType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmParameterType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmSignature(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmSimpleType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmStatusType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmTupleType(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::bmm3::core::entity::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_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::v1_1::bmm3::core::entity::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::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_FUNCTION_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INDEXED_CONTAINER_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmContainerType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PARAMETER_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmParameterType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROPERTY_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ROUTINE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIGNATURE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmSimpleType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STATUS_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_type::BmmType::BmmStatusType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_TUPLE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::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_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_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_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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmGenericType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_1::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmParameterType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_1::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSignature(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_1::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSimpleType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_1::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmStatusType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_1::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmTupleType(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_GENERIC_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmGenericType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PARAMETER_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmParameterType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROCEDURE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PROPERTY_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_ROUTINE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIGNATURE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSignature(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SIMPLE_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmSimpleType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STATUS_TYPE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::bmm_unitary_type::BmmUnitaryType::BmmStatusType(::serde::Deserialize::deserialize(__rest)?)),
"BMM_TUPLE_TYPE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::bmm3::core::literal_value::bmm_unitary_value::BmmUnitaryValue::BmmPrimitiveValue(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::literal_value::bmm_unitary_value::BmmUnitaryValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_INTEGER_VALUE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::literal_value::bmm_unitary_value::BmmUnitaryValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PRIMITIVE_VALUE" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::literal_value::bmm_unitary_value::BmmUnitaryValue::BmmPrimitiveValue(::serde::Deserialize::deserialize(__rest)?)),
"BMM_STRING_VALUE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::core::entity::range_constrained::bmm_value_set_spec::BmmValueSetSpec
{
    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_VALUE_SET_SPEC", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_VALUE_SET_SPEC")?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "resource_id",
            &self.resource_id,
        )?;
        ::serde::ser::SerializeStruct::serialize_field(
            &mut __st,
            "value_set_id",
            &self.value_set_id,
        )?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm3::core::entity::range_constrained::bmm_value_set_spec::BmmValueSetSpec
{
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __FIELDS: &[&str] = &["resource_id", "value_set_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),
                            "resource_id" => ::core::result::Result::Ok(__Field::__F0),
                            "value_set_id" => ::core::result::Result::Ok(__Field::__F1),
                            _ => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unknown_field(
                                    __v,
                                    "BMM_VALUE_SET_SPEC",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::bmm3::core::entity::range_constrained::bmm_value_set_spec::BmmValueSetSpec;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_VALUE_SET_SPEC` 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_VALUE_SET_SPEC"),
                            )?;
                        }
                        __Field::__F0 => {
                            if __s0.is_some() {
                                return ::core::result::Result::Err(
                                    ::serde::de::Error::duplicate_field("resource_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("value_set_id"),
                                );
                            }
                            __s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
                        }
                    }
                }
                ::core::result::Result::Ok(crate::v1_1::bmm3::core::entity::range_constrained::bmm_value_set_spec::BmmValueSetSpec {
resource_id: __s0.flatten().ok_or_else(|| ::serde::de::Error::missing_field("resource_id"))?,
value_set_id: __s1.flatten().ok_or_else(|| ::serde::de::Error::missing_field("value_set_id"))?,
})
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_VALUE_SET_SPEC",
            __FIELDS,
            __Visitor,
        )
    }
}

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

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::feature::bmm_variable::BmmVariable::BmmLocal(::serde::Deserialize::deserialize(__rest)?)),
"BMM_PARAMETER" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::feature::bmm_variable::BmmVariable::BmmParameter(::serde::Deserialize::deserialize(__rest)?)),
"BMM_RESULT" => ::core::result::Result::Ok(crate::v1_1::bmm3::core::feature::bmm_variable::BmmVariable::BmmResult(::serde::Deserialize::deserialize(__rest)?)),
"BMM_SELF" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::core::feature::bmm_visibility::BmmVisibility {
    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_VISIBILITY", __n)?;
        ::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "BMM_VISIBILITY")?;
        ::serde::ser::SerializeStruct::end(__st)
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::bmm3::core::feature::bmm_visibility::BmmVisibility
{
    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_VISIBILITY",
                                    __FIELDS,
                                ),
                            ),
                        }
                    }
                }
                ::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
            }
        }
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = crate::v1_1::bmm3::core::feature::bmm_visibility::BmmVisibility;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an openEHR `BMM_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;
                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_VISIBILITY"),
                            )?;
                        }
                    }
                }
                ::core::result::Result::Ok(
                    crate::v1_1::bmm3::core::feature::bmm_visibility::BmmVisibility {},
                )
            }
        }
        ::serde::Deserializer::deserialize_struct(
            __deserializer,
            "BMM_VISIBILITY",
            __FIELDS,
            __Visitor,
        )
    }
}

impl ::serde::Serialize
    for crate::v1_1::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::v1_1::bmm3::core::feature::bmm_writable_variable::BmmWritableVariable::BmmLocal(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::core::feature::bmm_writable_variable::BmmWritableVariable::BmmResult(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::core::feature::bmm_writable_variable::BmmWritableVariable::BmmLocal(::serde::Deserialize::deserialize(__rest)?)),
"BMM_RESULT" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::expression::el_agent::ElAgent {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::expression::el_agent::ElAgent::ElFunctionAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_agent::ElAgent::ElProcedureAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_agent::ElAgent::ElFunctionAgent(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(
                                crate::v1_1::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::v1_1::bmm3::expression::el_agent_call::ElAgentCall {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::expression::el_agent_call::ElAgentCall::BmmProcedureCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_agent_call::ElAgentCall::ElFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_agent_call::ElAgentCall::BmmProcedureCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_constrained::ElConstrained {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::expression::el_constrained::ElConstrained::ElBooleanExpression(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_decision_branch::ElDecisionBranch::ElCase(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::expression::el_decision_branch::ElDecisionBranch::ElConditionalExpression(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de, T: ::serde::de::DeserializeOwned> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_decision_branch::ElDecisionBranch::ElCase(::serde::Deserialize::deserialize(__rest)?)),
"EL_CONDITIONAL_EXPRESSION" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_decision_table::ElDecisionTable::ElCaseTable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_decision_table::ElDecisionTable::ElConditionChain(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de, T: ::serde::de::DeserializeOwned> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_decision_table::ElDecisionTable::ElCaseTable(::serde::Deserialize::deserialize(__rest)?)),
"EL_CONDITION_CHAIN" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_expression::ElExpression {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::expression::el_expression::ElExpression::ElAttached(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_expression::ElExpression::ElBinaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_expression::ElExpression::ElBooleanExpression(
                __x,
            ) => ::serde::Serialize::serialize(__x, __serializer),
            crate::v1_1::bmm3::expression::el_expression::ElExpression::ElCaseTable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_expression::ElExpression::ElConditionChain(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_expression::ElExpression::ElDefined(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_expression::ElExpression::ElFunctionAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_expression::ElExpression::ElFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_expression::ElExpression::ElLiteral(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_expression::ElExpression::ElProcedureAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_expression::ElExpression::ElPropertyRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_expression::ElExpression::ElReadonlyVariable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_expression::ElExpression::ElStaticRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_expression::ElExpression::ElTuple(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_expression::ElExpression::ElTypeRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_expression::ElExpression::ElUnaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_expression::ElExpression::ElWritableVariable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_expression::ElExpression::ElAttached(::serde::Deserialize::deserialize(__rest)?)),
"EL_BINARY_OPERATOR" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_expression::ElExpression::ElBinaryOperator(::serde::Deserialize::deserialize(__rest)?)),
"EL_BOOLEAN_EXPRESSION" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_expression::ElExpression::ElBooleanExpression(::serde::Deserialize::deserialize(__rest)?)),
"EL_CASE_TABLE" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_expression::ElExpression::ElCaseTable(::serde::Deserialize::deserialize(__rest)?)),
"EL_CONDITION_CHAIN" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_expression::ElExpression::ElConditionChain(::serde::Deserialize::deserialize(__rest)?)),
"EL_DEFINED" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_expression::ElExpression::ElDefined(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_AGENT" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_expression::ElExpression::ElFunctionAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_expression::ElExpression::ElFunctionCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_LITERAL" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_expression::ElExpression::ElLiteral(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_expression::ElExpression::ElProcedureAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROPERTY_REF" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_expression::ElExpression::ElPropertyRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_READONLY_VARIABLE" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_expression::ElExpression::ElReadonlyVariable(::serde::Deserialize::deserialize(__rest)?)),
"EL_STATIC_REF" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_expression::ElExpression::ElStaticRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_TUPLE" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_expression::ElExpression::ElTuple(::serde::Deserialize::deserialize(__rest)?)),
"EL_TYPE_REF" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_expression::ElExpression::ElTypeRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_UNARY_OPERATOR" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_expression::ElExpression::ElUnaryOperator(::serde::Deserialize::deserialize(__rest)?)),
"EL_WRITABLE_VARIABLE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::expression::el_feature_ref::ElFeatureRef {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::expression::el_feature_ref::ElFeatureRef::ElFunctionAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_feature_ref::ElFeatureRef::ElFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_feature_ref::ElFeatureRef::ElProcedureAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_feature_ref::ElFeatureRef::ElPropertyRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_feature_ref::ElFeatureRef::ElStaticRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_feature_ref::ElFeatureRef::ElFunctionAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_feature_ref::ElFeatureRef::ElFunctionCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_feature_ref::ElFeatureRef::ElProcedureAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROPERTY_REF" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_feature_ref::ElFeatureRef::ElPropertyRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_STATIC_REF" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_operator::ElOperator {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::expression::el_operator::ElOperator::ElBinaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_operator::ElOperator::ElUnaryOperator(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_operator::ElOperator::ElBinaryOperator(::serde::Deserialize::deserialize(__rest)?)),
"EL_UNARY_OPERATOR" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::expression::el_predicate::ElPredicate {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::expression::el_predicate::ElPredicate::ElAttached(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_predicate::ElPredicate::ElDefined(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_predicate::ElPredicate::ElAttached(::serde::Deserialize::deserialize(__rest)?)),
"EL_DEFINED" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_simple::ElSimple {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::expression::el_simple::ElSimple::ElAttached(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_simple::ElSimple::ElDefined(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_simple::ElSimple::ElFunctionAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_simple::ElSimple::ElFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_simple::ElSimple::ElLiteral(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_simple::ElSimple::ElProcedureAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_simple::ElSimple::ElPropertyRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_simple::ElSimple::ElReadonlyVariable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_simple::ElSimple::ElStaticRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_simple::ElSimple::ElTypeRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_simple::ElSimple::ElWritableVariable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_simple::ElSimple::ElAttached(::serde::Deserialize::deserialize(__rest)?)),
"EL_DEFINED" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_simple::ElSimple::ElDefined(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_AGENT" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_simple::ElSimple::ElFunctionAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_simple::ElSimple::ElFunctionCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_LITERAL" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_simple::ElSimple::ElLiteral(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_simple::ElSimple::ElProcedureAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROPERTY_REF" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_simple::ElSimple::ElPropertyRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_READONLY_VARIABLE" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_simple::ElSimple::ElReadonlyVariable(::serde::Deserialize::deserialize(__rest)?)),
"EL_STATIC_REF" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_simple::ElSimple::ElStaticRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_TYPE_REF" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_simple::ElSimple::ElTypeRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_WRITABLE_VARIABLE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_terminal::ElTerminal {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElAttached(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElCaseTable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElConditionChain(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElDefined(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElFunctionAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElFunctionCall(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElLiteral(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElProcedureAgent(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElPropertyRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElReadonlyVariable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElStaticRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElTypeRef(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElWritableVariable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_terminal::ElTerminal::ElAttached(::serde::Deserialize::deserialize(__rest)?)),
"EL_CASE_TABLE" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElCaseTable(::serde::Deserialize::deserialize(__rest)?)),
"EL_CONDITION_CHAIN" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElConditionChain(::serde::Deserialize::deserialize(__rest)?)),
"EL_DEFINED" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElDefined(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_AGENT" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElFunctionAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElFunctionCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_LITERAL" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElLiteral(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElProcedureAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROPERTY_REF" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElPropertyRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_READONLY_VARIABLE" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElReadonlyVariable(::serde::Deserialize::deserialize(__rest)?)),
"EL_STATIC_REF" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElStaticRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_TYPE_REF" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_terminal::ElTerminal::ElTypeRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_WRITABLE_VARIABLE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_value_generator::ElValueGenerator {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
crate::v1_1::bmm3::expression::el_value_generator::ElValueGenerator::ElFunctionAgent(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::expression::el_value_generator::ElValueGenerator::ElFunctionCall(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::expression::el_value_generator::ElValueGenerator::ElProcedureAgent(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::expression::el_value_generator::ElValueGenerator::ElPropertyRef(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::expression::el_value_generator::ElValueGenerator::ElReadonlyVariable(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::expression::el_value_generator::ElValueGenerator::ElStaticRef(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::expression::el_value_generator::ElValueGenerator::ElTypeRef(__x) => ::serde::Serialize::serialize(__x, __serializer),
crate::v1_1::bmm3::expression::el_value_generator::ElValueGenerator::ElWritableVariable(__x) => ::serde::Serialize::serialize(__x, __serializer),
}
    }
}

impl<'de> ::serde::Deserialize<'de>
    for crate::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_value_generator::ElValueGenerator::ElFunctionAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_FUNCTION_CALL" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_value_generator::ElValueGenerator::ElFunctionCall(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROCEDURE_AGENT" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_value_generator::ElValueGenerator::ElProcedureAgent(::serde::Deserialize::deserialize(__rest)?)),
"EL_PROPERTY_REF" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_value_generator::ElValueGenerator::ElPropertyRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_READONLY_VARIABLE" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_value_generator::ElValueGenerator::ElReadonlyVariable(::serde::Deserialize::deserialize(__rest)?)),
"EL_STATIC_REF" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_value_generator::ElValueGenerator::ElStaticRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_TYPE_REF" => ::core::result::Result::Ok(crate::v1_1::bmm3::expression::el_value_generator::ElValueGenerator::ElTypeRef(::serde::Deserialize::deserialize(__rest)?)),
"EL_WRITABLE_VARIABLE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::bmm3::expression::el_variable::ElVariable {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            crate::v1_1::bmm3::expression::el_variable::ElVariable::ElReadonlyVariable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
            crate::v1_1::bmm3::expression::el_variable::ElVariable::ElWritableVariable(__x) => {
                ::serde::Serialize::serialize(__x, __serializer)
            }
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for crate::v1_1::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::v1_1::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::v1_1::bmm3::expression::el_variable::ElVariable::ElReadonlyVariable(::serde::Deserialize::deserialize(__rest)?)),
"EL_WRITABLE_VARIABLE" => ::core::result::Result::Ok(crate::v1_1::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::v1_1::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::v1_1::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::v1_1::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::v1_1::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,
        )
    }
}