open_plc_schema 0.1.0

use xsd_parser::models::schema::Namespace;
pub const NS_XS: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema");
pub const NS_XML: Namespace = Namespace::new_const(b"http://www.w3.org/XML/1998/namespace");
pub const NS_PPX: Namespace = Namespace::new_const(b"http://www.plcopen.org/xml/tc6_0201");
pub mod ppx {
    use num::BigInt;
    use std::borrow::Cow;
    use xsd_parser::{
        quick_xml::{
            DeserializeBytes, DeserializeReader, Error, ErrorKind, RawByteStr, SerializeBytes,
            WithDeserializer, WithSerializer,
        },
        xml::AnyElement,
    };
    #[doc = "Defines the different access types to an accessVariable"]
    #[derive(Debug)]
    pub enum AccessType {
        ReadOnly,
        ReadWrite,
    }
    impl DeserializeBytes for AccessType {
        fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, Error>
        where
            R: DeserializeReader,
        {
            match bytes {
                b"readOnly" => Ok(Self::ReadOnly),
                b"readWrite" => Ok(Self::ReadWrite),
                x => {
                    Err(reader
                        .map_error(ErrorKind::UnknownOrInvalidValue(RawByteStr::from_slice(x))))
                }
            }
        }
    }
    impl SerializeBytes for AccessType {
        fn serialize_bytes(&self) -> Result<Option<Cow<'_, str>>, Error> {
            match self {
                Self::ReadOnly => Ok(Some(Cow::Borrowed("readOnly"))),
                Self::ReadWrite => Ok(Some(Cow::Borrowed("readWrite"))),
            }
        }
    }
    #[doc = "Application specific data defined in external schemata"]
    #[derive(Debug)]
    pub struct AddDataType {
        pub data: Vec<AddDataDataElementType>,
    }
    impl WithDeserializer for AddDataType {
        type Deserializer = Box<quick_xml_deserialize::AddDataTypeDeserializer>;
    }
    impl WithSerializer for AddDataType {
        type Serializer<'x> = quick_xml_serialize::AddDataTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::AddDataTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::AddDataTypeSerializerState::Init__),
                name: name.unwrap_or("addData"),
                is_root,
            })
        }
    }
    #[doc = "List of additional data elements used in the document with"]
    #[doc = "description"]
    #[derive(Debug)]
    pub struct AddDataInfoType {
        pub info: Vec<AddDataInfoInfoElementType>,
    }
    impl WithDeserializer for AddDataInfoType {
        type Deserializer = Box<quick_xml_deserialize::AddDataInfoTypeDeserializer>;
    }
    impl WithSerializer for AddDataInfoType {
        type Serializer<'x> = quick_xml_serialize::AddDataInfoTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::AddDataInfoTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::AddDataInfoTypeSerializerState::Init__),
                name: name.unwrap_or("addDataInfo"),
                is_root,
            })
        }
    }
    #[doc = "Implementation part of a POU, action or transistion"]
    #[derive(Debug)]
    pub struct BodyType {
        pub worksheet_name: Option<::std::string::String>,
        pub global_id: Option<::std::string::String>,
        pub content: Vec<BodyTypeContent>,
    }
    #[doc = "Implementation part of a POU, action or transistion"]
    #[derive(Debug)]
    pub enum BodyTypeContent {
        Il(FormattedTextType),
        St(FormattedTextType),
        Fbd(BodyFbdElementType),
        Ld(BodyLdElementType),
        Sfc(BodySfcElementType),
        AddData(AddDataType),
        #[doc = "Additional userspecific information to the element"]
        Documentation(FormattedTextType),
    }
    impl WithDeserializer for BodyType {
        type Deserializer = Box<quick_xml_deserialize::BodyTypeDeserializer>;
    }
    impl WithDeserializer for BodyTypeContent {
        type Deserializer = Box<quick_xml_deserialize::BodyTypeContentDeserializer>;
    }
    impl WithSerializer for BodyType {
        type Serializer<'x> = quick_xml_serialize::BodyTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::BodyTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::BodyTypeSerializerState::Init__),
                name: name.unwrap_or("body"),
                is_root,
            })
        }
    }
    impl WithSerializer for BodyTypeContent {
        type Serializer<'x> = quick_xml_serialize::BodyTypeContentSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            let _name = name;
            let _is_root = is_root;
            Ok(quick_xml_serialize::BodyTypeContentSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::BodyTypeContentSerializerState::Init__),
            })
        }
    }
    #[doc = "Describes a connection between the consumer element (eg. input"]
    #[doc = "variable of a function block) and the producer element (eg. output variable of a"]
    #[doc = "function block). It may contain a list of positions that describes the path of the"]
    #[doc = "connection."]
    #[derive(Debug)]
    pub struct ConnectionType {
        pub global_id: Option<::std::string::String>,
        #[doc = "Identifies the element the connection starts from."]
        pub ref_local_id: ::core::primitive::u64,
        #[doc = "If present: This attribute denotes the name of the VAR_OUTPUT /"]
        #[doc = "VAR_IN_OUTparameter of the pou block that is the start of the connection. If not"]
        #[doc = "present: If the refLocalId attribute refers to a pou block, the start of the"]
        #[doc = "connection is the first output of this block, which is not ENO. If the"]
        #[doc = "refLocalId attribute refers to any other element type, the start of the"]
        #[doc = "connection is the elements single native output."]
        pub formal_parameter: Option<::std::string::String>,
        #[doc = "All positions of the directed connection path. If any"]
        #[doc = "positions are given, the list has to contain the first (input pin of the"]
        #[doc = "consumer element) as well as the last (output pin of the producer element)."]
        pub position: Vec<PositionType>,
        pub add_data: Option<AddDataType>,
    }
    impl WithDeserializer for ConnectionType {
        type Deserializer = Box<quick_xml_deserialize::ConnectionTypeDeserializer>;
    }
    impl WithSerializer for ConnectionType {
        type Serializer<'x> = quick_xml_serialize::ConnectionTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::ConnectionTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::ConnectionTypeSerializerState::Init__),
                name: name.unwrap_or("connection"),
                is_root,
            })
        }
    }
    #[doc = "Defines a connection point on the consumer side"]
    #[derive(Debug)]
    pub struct ConnectionPointInType {
        pub global_id: Option<::std::string::String>,
        pub content: Vec<ConnectionPointInTypeContent>,
    }
    #[doc = "Defines a connection point on the consumer side"]
    #[derive(Debug)]
    pub enum ConnectionPointInTypeContent {
        #[doc = "Relative position of the connection pin. Origin is the anchor"]
        #[doc = "position of the block."]
        RelPosition(PositionType),
        Connection(ConnectionType),
        #[doc = "The operand is a valid iec variable e.g. avar[0] or an"]
        #[doc = "iec expression or multiple token text e.g. a + b (*sum*). An iec 61131-3"]
        #[doc = "parser has to be used to extract variable information."]
        Expression(::std::string::String),
        AddData(AddDataType),
    }
    impl WithDeserializer for ConnectionPointInType {
        type Deserializer = Box<quick_xml_deserialize::ConnectionPointInTypeDeserializer>;
    }
    impl WithDeserializer for ConnectionPointInTypeContent {
        type Deserializer = Box<quick_xml_deserialize::ConnectionPointInTypeContentDeserializer>;
    }
    impl WithSerializer for ConnectionPointInType {
        type Serializer<'x> = quick_xml_serialize::ConnectionPointInTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::ConnectionPointInTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::ConnectionPointInTypeSerializerState::Init__),
                name: name.unwrap_or("connectionPointIn"),
                is_root,
            })
        }
    }
    impl WithSerializer for ConnectionPointInTypeContent {
        type Serializer<'x> = quick_xml_serialize::ConnectionPointInTypeContentSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            let _name = name;
            let _is_root = is_root;
            Ok(
                quick_xml_serialize::ConnectionPointInTypeContentSerializer {
                    value: self,
                    state: Box::new(
                        quick_xml_serialize::ConnectionPointInTypeContentSerializerState::Init__,
                    ),
                },
            )
        }
    }
    #[doc = "Defines a connection point on the producer side"]
    #[derive(Debug)]
    pub struct ConnectionPointOutType {
        pub global_id: Option<::std::string::String>,
        #[doc = "Relative position of the connection pin. Origin is the anchor"]
        #[doc = "position of the block."]
        pub rel_position: Option<PositionType>,
        #[doc = "The operand is a valid iec variable e.g. avar[0]."]
        pub expression: Option<::std::string::String>,
        pub add_data: Option<AddDataType>,
    }
    impl WithDeserializer for ConnectionPointOutType {
        type Deserializer = Box<quick_xml_deserialize::ConnectionPointOutTypeDeserializer>;
    }
    impl WithSerializer for ConnectionPointOutType {
        type Serializer<'x> = quick_xml_serialize::ConnectionPointOutTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::ConnectionPointOutTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::ConnectionPointOutTypeSerializerState::Init__),
                name: name.unwrap_or("connectionPointOut"),
                is_root,
            })
        }
    }
    #[doc = "A generic data type"]
    #[derive(Debug)]
    pub enum DataType {
        Bool(super::xs::AnyType),
        Byte(super::xs::AnyType),
        Word(super::xs::AnyType),
        Dword(super::xs::AnyType),
        Lword(super::xs::AnyType),
        Sint(super::xs::AnyType),
        Int(super::xs::AnyType),
        Dint(super::xs::AnyType),
        Lint(super::xs::AnyType),
        Usint(super::xs::AnyType),
        Uint(super::xs::AnyType),
        Udint(super::xs::AnyType),
        Ulint(super::xs::AnyType),
        Real(super::xs::AnyType),
        Lreal(super::xs::AnyType),
        Time(super::xs::AnyType),
        Date(super::xs::AnyType),
        Dt(super::xs::AnyType),
        Tod(super::xs::AnyType),
        String(StringElementType),
        Wstring(StringElementType),
        Any(super::xs::AnyType),
        AnyDerived(super::xs::AnyType),
        AnyElementary(super::xs::AnyType),
        AnyMagnitude(super::xs::AnyType),
        AnyNum(super::xs::AnyType),
        AnyReal(super::xs::AnyType),
        AnyInt(super::xs::AnyType),
        AnyBit(super::xs::AnyType),
        AnyString(super::xs::AnyType),
        AnyDate(super::xs::AnyType),
        Array(Box<ArrayElementType>),
        #[doc = "Reference to a user defined datatype or POU. Variable"]
        #[doc = "declarations use this type to declare e.g. function block instances."]
        Derived(DerivedElementType),
        Enum(Box<EnumElementType>),
        Struct(VarListPlainType),
        SubrangeSigned(Box<SubrangeSignedElementType>),
        SubrangeUnsigned(Box<SubrangeSignedElementType>),
        Pointer(Box<PointerElementType>),
    }
    impl WithDeserializer for DataType {
        type Deserializer = Box<quick_xml_deserialize::DataTypeDeserializer>;
    }
    impl WithSerializer for DataType {
        type Serializer<'x> = quick_xml_serialize::DataTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::DataTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::DataTypeSerializerState::Init__),
                name: name.unwrap_or("dataType"),
                is_root,
            })
        }
    }
    #[doc = "Defines the edge detection behaviour of a variable"]
    #[derive(Debug)]
    pub enum EdgeModifierType {
        None,
        Falling,
        Rising,
    }
    impl DeserializeBytes for EdgeModifierType {
        fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, Error>
        where
            R: DeserializeReader,
        {
            match bytes {
                b"none" => Ok(Self::None),
                b"falling" => Ok(Self::Falling),
                b"rising" => Ok(Self::Rising),
                x => {
                    Err(reader
                        .map_error(ErrorKind::UnknownOrInvalidValue(RawByteStr::from_slice(x))))
                }
            }
        }
    }
    impl SerializeBytes for EdgeModifierType {
        fn serialize_bytes(&self) -> Result<Option<Cow<'_, str>>, Error> {
            match self {
                Self::None => Ok(Some(Cow::Borrowed("none"))),
                Self::Falling => Ok(Some(Cow::Borrowed("falling"))),
                Self::Rising => Ok(Some(Cow::Borrowed("rising"))),
            }
        }
    }
    #[doc = "Formatted text according to parts of XHTML 1.1"]
    #[derive(Debug)]
    pub struct FormattedTextType {
        pub any: AnyElement,
    }
    impl WithDeserializer for FormattedTextType {
        type Deserializer = Box<quick_xml_deserialize::FormattedTextTypeDeserializer>;
    }
    impl WithSerializer for FormattedTextType {
        type Serializer<'x> = quick_xml_serialize::FormattedTextTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::FormattedTextTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::FormattedTextTypeSerializerState::Init__),
                name: name.unwrap_or("formattedText"),
                is_root,
            })
        }
    }
    #[doc = "Defines a graphical position in X, Y coordinates"]
    #[derive(Debug)]
    pub struct PositionType {
        pub x: ::core::primitive::f64,
        pub y: ::core::primitive::f64,
    }
    impl WithDeserializer for PositionType {
        type Deserializer = Box<quick_xml_deserialize::PositionTypeDeserializer>;
    }
    impl WithSerializer for PositionType {
        type Serializer<'x> = quick_xml_serialize::PositionTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::PositionTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::PositionTypeSerializerState::Init__),
                name: name.unwrap_or("position"),
                is_root,
            })
        }
    }
    #[doc = "Represents a program or function block instance either running with"]
    #[doc = "or without a task"]
    #[derive(Debug)]
    pub struct PouInstanceType {
        pub name: ::std::string::String,
        pub type_name: ::std::string::String,
        pub global_id: Option<::std::string::String>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for PouInstanceType {
        type Deserializer = Box<quick_xml_deserialize::PouInstanceTypeDeserializer>;
    }
    impl WithSerializer for PouInstanceType {
        type Serializer<'x> = quick_xml_serialize::PouInstanceTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::PouInstanceTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::PouInstanceTypeSerializerState::Init__),
                name: name.unwrap_or("pouInstance"),
                is_root,
            })
        }
    }
    #[doc = "Defines the different types of a POU"]
    #[derive(Debug)]
    pub enum PouType {
        Function,
        FunctionBlock,
        Program,
    }
    impl DeserializeBytes for PouType {
        fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, Error>
        where
            R: DeserializeReader,
        {
            match bytes {
                b"function" => Ok(Self::Function),
                b"functionBlock" => Ok(Self::FunctionBlock),
                b"program" => Ok(Self::Program),
                x => {
                    Err(reader
                        .map_error(ErrorKind::UnknownOrInvalidValue(RawByteStr::from_slice(x))))
                }
            }
        }
    }
    impl SerializeBytes for PouType {
        fn serialize_bytes(&self) -> Result<Option<Cow<'_, str>>, Error> {
            match self {
                Self::Function => Ok(Some(Cow::Borrowed("function"))),
                Self::FunctionBlock => Ok(Some(Cow::Borrowed("functionBlock"))),
                Self::Program => Ok(Some(Cow::Borrowed("program"))),
            }
        }
    }
    #[doc = "The complete project"]
    pub type Project = ProjectElementType;
    #[derive(Debug)]
    pub struct ProjectElementType {
        pub file_header: ProjectFileHeaderElementType,
        pub content_header: ProjectContentHeaderElementType,
        pub types: ProjectTypesElementType,
        pub instances: ProjectInstancesElementType,
        pub add_data: Option<AddDataType>,
        #[doc = "Additional userspecific information to the element"]
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for ProjectElementType {
        type Deserializer = Box<quick_xml_deserialize::ProjectElementTypeDeserializer>;
    }
    impl WithSerializer for ProjectElementType {
        type Serializer<'x> = quick_xml_serialize::ProjectElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::ProjectElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::ProjectElementTypeSerializerState::Init__),
                name: name.unwrap_or("project"),
                is_root,
            })
        }
    }
    #[doc = "Defines a range with signed bounds"]
    #[derive(Debug)]
    pub struct RangeSignedType {
        pub lower: ::std::string::String,
        pub upper: ::std::string::String,
    }
    impl WithDeserializer for RangeSignedType {
        type Deserializer = Box<quick_xml_deserialize::RangeSignedTypeDeserializer>;
    }
    impl WithSerializer for RangeSignedType {
        type Serializer<'x> = quick_xml_serialize::RangeSignedTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::RangeSignedTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::RangeSignedTypeSerializerState::Init__),
                name: name.unwrap_or("rangeSigned"),
                is_root,
            })
        }
    }
    #[doc = "Defines a range with unsigned bounds"]
    pub type RangeUnsignedType = RangeSignedType;
    #[doc = "Defines the storage mode (S/R) behaviour of a variable"]
    #[derive(Debug)]
    pub enum StorageModifierType {
        None,
        Set,
        Reset,
    }
    impl DeserializeBytes for StorageModifierType {
        fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, Error>
        where
            R: DeserializeReader,
        {
            match bytes {
                b"none" => Ok(Self::None),
                b"set" => Ok(Self::Set),
                b"reset" => Ok(Self::Reset),
                x => {
                    Err(reader
                        .map_error(ErrorKind::UnknownOrInvalidValue(RawByteStr::from_slice(x))))
                }
            }
        }
    }
    impl SerializeBytes for StorageModifierType {
        fn serialize_bytes(&self) -> Result<Option<Cow<'_, str>>, Error> {
            match self {
                Self::None => Ok(Some(Cow::Borrowed("none"))),
                Self::Set => Ok(Some(Cow::Borrowed("set"))),
                Self::Reset => Ok(Some(Cow::Borrowed("reset"))),
            }
        }
    }
    #[doc = "A generic value"]
    #[derive(Debug)]
    pub enum ValueType {
        SimpleValue(ValueSimpleValueElementType),
        ArrayValue(ValueArrayValueElementType),
        StructValue(ValueStructValueElementType),
    }
    impl WithDeserializer for ValueType {
        type Deserializer = Box<quick_xml_deserialize::ValueTypeDeserializer>;
    }
    impl WithSerializer for ValueType {
        type Serializer<'x> = quick_xml_serialize::ValueTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::ValueTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::ValueTypeSerializerState::Init__),
                name: name.unwrap_or("value"),
                is_root,
            })
        }
    }
    #[doc = "List of variable declarations that share the same memory attributes"]
    #[doc = "(CONSTANT, RETAIN, NON_RETAIN, PERSISTENT)"]
    #[derive(Debug)]
    pub struct VarListType {
        pub name: Option<::std::string::String>,
        pub constant: ::core::primitive::bool,
        pub retain: ::core::primitive::bool,
        pub nonretain: ::core::primitive::bool,
        pub persistent: ::core::primitive::bool,
        pub nonpersistent: ::core::primitive::bool,
        pub variable: Vec<VarListPlainVariableElementType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl VarListType {
        #[must_use]
        pub fn default_constant() -> ::core::primitive::bool {
            false
        }
        #[must_use]
        pub fn default_retain() -> ::core::primitive::bool {
            false
        }
        #[must_use]
        pub fn default_nonretain() -> ::core::primitive::bool {
            false
        }
        #[must_use]
        pub fn default_persistent() -> ::core::primitive::bool {
            false
        }
        #[must_use]
        pub fn default_nonpersistent() -> ::core::primitive::bool {
            false
        }
    }
    impl WithDeserializer for VarListType {
        type Deserializer = Box<quick_xml_deserialize::VarListTypeDeserializer>;
    }
    impl WithSerializer for VarListType {
        type Serializer<'x> = quick_xml_serialize::VarListTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::VarListTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::VarListTypeSerializerState::Init__),
                name: name.unwrap_or("varList"),
                is_root,
            })
        }
    }
    #[doc = "List of access variable declarations"]
    #[derive(Debug)]
    pub struct VarListAccessType {
        pub access_variable: Vec<VarListAccessAccessVariableElementType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for VarListAccessType {
        type Deserializer = Box<quick_xml_deserialize::VarListAccessTypeDeserializer>;
    }
    impl WithSerializer for VarListAccessType {
        type Serializer<'x> = quick_xml_serialize::VarListAccessTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::VarListAccessTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::VarListAccessTypeSerializerState::Init__),
                name: name.unwrap_or("varListAccess"),
                is_root,
            })
        }
    }
    #[doc = "List of VAR_CONFIG variables"]
    #[derive(Debug)]
    pub struct VarListConfigType {
        pub config_variable: Vec<VarListConfigConfigVariableElementType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for VarListConfigType {
        type Deserializer = Box<quick_xml_deserialize::VarListConfigTypeDeserializer>;
    }
    impl WithSerializer for VarListConfigType {
        type Serializer<'x> = quick_xml_serialize::VarListConfigTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::VarListConfigTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::VarListConfigTypeSerializerState::Init__),
                name: name.unwrap_or("varListConfig"),
                is_root,
            })
        }
    }
    #[doc = "List of variable declarations without attributes"]
    #[derive(Debug)]
    pub struct VarListPlainType {
        pub variable: Vec<VarListPlainVariableElementType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for VarListPlainType {
        type Deserializer = Box<quick_xml_deserialize::VarListPlainTypeDeserializer>;
    }
    impl WithSerializer for VarListPlainType {
        type Serializer<'x> = quick_xml_serialize::VarListPlainTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::VarListPlainTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::VarListPlainTypeSerializerState::Init__),
                name: name.unwrap_or("varListPlain"),
                is_root,
            })
        }
    }
    #[derive(Debug)]
    pub struct AddDataDataElementType {
        #[doc = "Uniquely identifies the additional data element."]
        pub name: ::std::string::String,
        #[doc = "Recommended processor handling for unknown data"]
        #[doc = "elements. Specifies if the processor should try to preserve the"]
        #[doc = "additional data element, dismiss the element (e.g. because the data"]
        #[doc = "is invalid if not updated correctly) or use the processors default"]
        #[doc = "behaviour for unknown data."]
        pub handle_unknown: AddDataDataHandleUnknownType,
        pub any: AnyElement,
    }
    impl WithDeserializer for AddDataDataElementType {
        type Deserializer = Box<quick_xml_deserialize::AddDataDataElementTypeDeserializer>;
    }
    impl WithSerializer for AddDataDataElementType {
        type Serializer<'x> = quick_xml_serialize::AddDataDataElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::AddDataDataElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::AddDataDataElementTypeSerializerState::Init__),
                name: name.unwrap_or("AddDataData"),
                is_root,
            })
        }
    }
    #[derive(Debug)]
    pub struct AddDataInfoInfoElementType {
        #[doc = "Unique name of the additional data element."]
        pub name: ::std::string::String,
        #[doc = "Version of additional data, eg. schema version."]
        pub version: Option<::core::primitive::f64>,
        #[doc = "Vendor responsible for the definition of the"]
        #[doc = "additional data element."]
        pub vendor: ::std::string::String,
        pub description: Option<FormattedTextType>,
    }
    impl WithDeserializer for AddDataInfoInfoElementType {
        type Deserializer = Box<quick_xml_deserialize::AddDataInfoInfoElementTypeDeserializer>;
    }
    impl WithSerializer for AddDataInfoInfoElementType {
        type Serializer<'x> = quick_xml_serialize::AddDataInfoInfoElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::AddDataInfoInfoElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::AddDataInfoInfoElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("AddDataInfoInfo"),
                is_root,
            })
        }
    }
    #[derive(Debug)]
    pub struct BodyFbdElementType {
        pub content: Vec<BodyFbdElementTypeContent>,
    }
    #[derive(Debug)]
    pub enum BodyFbdElementTypeContent {
        Comment(CommentElementType),
        Error(CommentElementType),
        Connector(ConnectorElementType),
        #[doc = "Counterpart of the connector element"]
        Continuation(ContinuationElementType),
        ActionBlock(ActionBlockElementType),
        VendorElement(VendorElementElementType),
        Block(BlockElementType),
        #[doc = "Expression used as producer"]
        InVariable(InVariableElementType),
        #[doc = "Expression used as consumer"]
        OutVariable(OutVariableElementType),
        #[doc = "Expression used as producer and consumer"]
        InOutVariable(InOutVariableElementType),
        Label(LabelElementType),
        Jump(JumpElementType),
        Return(ReturnElementType),
    }
    impl WithDeserializer for BodyFbdElementType {
        type Deserializer = Box<quick_xml_deserialize::BodyFbdElementTypeDeserializer>;
    }
    impl WithDeserializer for BodyFbdElementTypeContent {
        type Deserializer = Box<quick_xml_deserialize::BodyFbdElementTypeContentDeserializer>;
    }
    impl WithSerializer for BodyFbdElementType {
        type Serializer<'x> = quick_xml_serialize::BodyFbdElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::BodyFbdElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::BodyFbdElementTypeSerializerState::Init__),
                name: name.unwrap_or("BodyFbd"),
                is_root,
            })
        }
    }
    impl WithSerializer for BodyFbdElementTypeContent {
        type Serializer<'x> = quick_xml_serialize::BodyFbdElementTypeContentSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            let _name = name;
            let _is_root = is_root;
            Ok(quick_xml_serialize::BodyFbdElementTypeContentSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::BodyFbdElementTypeContentSerializerState::Init__,
                ),
            })
        }
    }
    #[derive(Debug)]
    pub struct BodyLdElementType {
        pub content: Vec<BodyLdElementTypeContent>,
    }
    #[derive(Debug)]
    pub enum BodyLdElementTypeContent {
        Comment(CommentElementType),
        Error(CommentElementType),
        Connector(ConnectorElementType),
        #[doc = "Counterpart of the connector element"]
        Continuation(ContinuationElementType),
        ActionBlock(ActionBlockElementType),
        VendorElement(VendorElementElementType),
        Block(BlockElementType),
        #[doc = "Expression used as producer"]
        InVariable(InVariableElementType),
        #[doc = "Expression used as consumer"]
        OutVariable(OutVariableElementType),
        #[doc = "Expression used as producer and consumer"]
        InOutVariable(InOutVariableElementType),
        Label(LabelElementType),
        Jump(JumpElementType),
        Return(ReturnElementType),
        LeftPowerRail(LeftPowerRailElementType),
        RightPowerRail(RightPowerRailElementType),
        Coil(CoilElementType),
        Contact(CoilElementType),
    }
    impl WithDeserializer for BodyLdElementType {
        type Deserializer = Box<quick_xml_deserialize::BodyLdElementTypeDeserializer>;
    }
    impl WithDeserializer for BodyLdElementTypeContent {
        type Deserializer = Box<quick_xml_deserialize::BodyLdElementTypeContentDeserializer>;
    }
    impl WithSerializer for BodyLdElementType {
        type Serializer<'x> = quick_xml_serialize::BodyLdElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::BodyLdElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::BodyLdElementTypeSerializerState::Init__),
                name: name.unwrap_or("BodyLd"),
                is_root,
            })
        }
    }
    impl WithSerializer for BodyLdElementTypeContent {
        type Serializer<'x> = quick_xml_serialize::BodyLdElementTypeContentSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            let _name = name;
            let _is_root = is_root;
            Ok(quick_xml_serialize::BodyLdElementTypeContentSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::BodyLdElementTypeContentSerializerState::Init__,
                ),
            })
        }
    }
    #[derive(Debug)]
    pub struct BodySfcElementType {
        pub content: Vec<BodySfcElementTypeContent>,
    }
    #[derive(Debug)]
    pub enum BodySfcElementTypeContent {
        Comment(CommentElementType),
        Error(CommentElementType),
        Connector(ConnectorElementType),
        #[doc = "Counterpart of the connector element"]
        Continuation(ContinuationElementType),
        ActionBlock(ActionBlockElementType),
        VendorElement(VendorElementElementType),
        Block(BlockElementType),
        #[doc = "Expression used as producer"]
        InVariable(InVariableElementType),
        #[doc = "Expression used as consumer"]
        OutVariable(OutVariableElementType),
        #[doc = "Expression used as producer and consumer"]
        InOutVariable(InOutVariableElementType),
        Label(LabelElementType),
        Jump(JumpElementType),
        Return(ReturnElementType),
        LeftPowerRail(LeftPowerRailElementType),
        RightPowerRail(RightPowerRailElementType),
        Coil(CoilElementType),
        Contact(CoilElementType),
        #[doc = "A single step in a SFC Sequence. Actions are associated with"]
        #[doc = "a step by using an actionBlock element with a connection to the step element"]
        Step(StepElementType),
        MacroStep(MacroStepElementType),
        #[doc = "Jump to a step, macro step or simultaneous divergence. Acts"]
        #[doc = "like a step. Predecessor should be a transition."]
        JumpStep(JumpStepElementType),
        Transition(TransitionElementType),
        SelectionDivergence(SelectionDivergenceElementType),
        SelectionConvergence(SelectionConvergenceElementType),
        SimultaneousDivergence(SimultaneousDivergenceElementType),
        SimultaneousConvergence(SimultaneousConvergenceElementType),
    }
    impl WithDeserializer for BodySfcElementType {
        type Deserializer = Box<quick_xml_deserialize::BodySfcElementTypeDeserializer>;
    }
    impl WithDeserializer for BodySfcElementTypeContent {
        type Deserializer = Box<quick_xml_deserialize::BodySfcElementTypeContentDeserializer>;
    }
    impl WithSerializer for BodySfcElementType {
        type Serializer<'x> = quick_xml_serialize::BodySfcElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::BodySfcElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::BodySfcElementTypeSerializerState::Init__),
                name: name.unwrap_or("BodySfc"),
                is_root,
            })
        }
    }
    impl WithSerializer for BodySfcElementTypeContent {
        type Serializer<'x> = quick_xml_serialize::BodySfcElementTypeContentSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            let _name = name;
            let _is_root = is_root;
            Ok(quick_xml_serialize::BodySfcElementTypeContentSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::BodySfcElementTypeContentSerializerState::Init__,
                ),
            })
        }
    }
    #[doc = "The single byte character string type"]
    #[derive(Debug)]
    pub struct StringElementType {
        pub length: Option<::std::string::String>,
    }
    impl WithDeserializer for StringElementType {
        type Deserializer = Box<quick_xml_deserialize::StringElementTypeDeserializer>;
    }
    impl WithSerializer for StringElementType {
        type Serializer<'x> = quick_xml_serialize::StringElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::StringElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::StringElementTypeSerializerState::Init__),
                name: name.unwrap_or("String"),
                is_root,
            })
        }
    }
    #[derive(Debug)]
    pub struct ArrayElementType {
        pub dimension: Vec<RangeSignedType>,
        pub base_type: Box<DataType>,
    }
    impl WithDeserializer for ArrayElementType {
        type Deserializer = Box<quick_xml_deserialize::ArrayElementTypeDeserializer>;
    }
    impl WithSerializer for ArrayElementType {
        type Serializer<'x> = quick_xml_serialize::ArrayElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::ArrayElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::ArrayElementTypeSerializerState::Init__),
                name: name.unwrap_or("Array"),
                is_root,
            })
        }
    }
    #[doc = "The user defined alias type"]
    #[derive(Debug)]
    pub struct DerivedElementType {
        pub name: ::std::string::String,
        pub add_data: Option<AddDataType>,
    }
    impl WithDeserializer for DerivedElementType {
        type Deserializer = Box<quick_xml_deserialize::DerivedElementTypeDeserializer>;
    }
    impl WithSerializer for DerivedElementType {
        type Serializer<'x> = quick_xml_serialize::DerivedElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::DerivedElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::DerivedElementTypeSerializerState::Init__),
                name: name.unwrap_or("Derived"),
                is_root,
            })
        }
    }
    #[derive(Debug)]
    pub struct EnumElementType {
        pub values: EnumValuesElementType,
        pub base_type: Option<Box<DataType>>,
    }
    impl WithDeserializer for EnumElementType {
        type Deserializer = Box<quick_xml_deserialize::EnumElementTypeDeserializer>;
    }
    impl WithSerializer for EnumElementType {
        type Serializer<'x> = quick_xml_serialize::EnumElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::EnumElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::EnumElementTypeSerializerState::Init__),
                name: name.unwrap_or("Enum"),
                is_root,
            })
        }
    }
    #[derive(Debug)]
    pub struct SubrangeSignedElementType {
        pub range: RangeSignedType,
        pub base_type: Box<DataType>,
    }
    impl WithDeserializer for SubrangeSignedElementType {
        type Deserializer = Box<quick_xml_deserialize::SubrangeSignedElementTypeDeserializer>;
    }
    impl WithSerializer for SubrangeSignedElementType {
        type Serializer<'x> = quick_xml_serialize::SubrangeSignedElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::SubrangeSignedElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::SubrangeSignedElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("SubrangeSigned"),
                is_root,
            })
        }
    }
    #[derive(Debug)]
    pub struct PointerElementType {
        pub base_type: Box<DataType>,
    }
    impl WithDeserializer for PointerElementType {
        type Deserializer = Box<quick_xml_deserialize::PointerElementTypeDeserializer>;
    }
    impl WithSerializer for PointerElementType {
        type Serializer<'x> = quick_xml_serialize::PointerElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::PointerElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::PointerElementTypeSerializerState::Init__),
                name: name.unwrap_or("Pointer"),
                is_root,
            })
        }
    }
    #[derive(Debug)]
    pub struct ProjectFileHeaderElementType {
        pub company_name: ::std::string::String,
        pub company_url: Option<::std::string::String>,
        pub product_name: ::std::string::String,
        pub product_version: ::std::string::String,
        pub product_release: Option<::std::string::String>,
        pub creation_date_time: ::std::string::String,
        pub content_description: Option<::std::string::String>,
    }
    impl WithDeserializer for ProjectFileHeaderElementType {
        type Deserializer = Box<quick_xml_deserialize::ProjectFileHeaderElementTypeDeserializer>;
    }
    impl WithSerializer for ProjectFileHeaderElementType {
        type Serializer<'x> = quick_xml_serialize::ProjectFileHeaderElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(
                quick_xml_serialize::ProjectFileHeaderElementTypeSerializer {
                    value: self,
                    state: Box::new(
                        quick_xml_serialize::ProjectFileHeaderElementTypeSerializerState::Init__,
                    ),
                    name: name.unwrap_or("ProjectFileHeader"),
                    is_root,
                },
            )
        }
    }
    #[derive(Debug)]
    pub struct ProjectContentHeaderElementType {
        pub name: ::std::string::String,
        pub version: Option<::std::string::String>,
        pub modification_date_time: Option<::std::string::String>,
        pub organization: Option<::std::string::String>,
        pub author: Option<::std::string::String>,
        #[doc = "Documentation language of the project e.g."]
        #[doc = "\"en-US\""]
        pub language: Option<::std::string::String>,
        pub comment: Option<::std::string::String>,
        pub coordinate_info: ProjectContentHeaderCoordinateInfoElementType,
        pub add_data_info: Option<AddDataInfoType>,
        pub add_data: Option<AddDataType>,
    }
    impl WithDeserializer for ProjectContentHeaderElementType {
        type Deserializer = Box<quick_xml_deserialize::ProjectContentHeaderElementTypeDeserializer>;
    }
    impl WithSerializer for ProjectContentHeaderElementType {
        type Serializer<'x> = quick_xml_serialize::ProjectContentHeaderElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(
                quick_xml_serialize::ProjectContentHeaderElementTypeSerializer {
                    value: self,
                    state: Box::new(
                        quick_xml_serialize::ProjectContentHeaderElementTypeSerializerState::Init__,
                    ),
                    name: name.unwrap_or("ProjectContentHeader"),
                    is_root,
                },
            )
        }
    }
    #[derive(Debug)]
    pub struct ProjectTypesElementType {
        pub data_types: ProjectTypesDataTypesElementType,
        pub pous: ProjectTypesPousElementType,
    }
    impl WithDeserializer for ProjectTypesElementType {
        type Deserializer = Box<quick_xml_deserialize::ProjectTypesElementTypeDeserializer>;
    }
    impl WithSerializer for ProjectTypesElementType {
        type Serializer<'x> = quick_xml_serialize::ProjectTypesElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::ProjectTypesElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::ProjectTypesElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("ProjectTypes"),
                is_root,
            })
        }
    }
    #[derive(Debug)]
    pub struct ProjectInstancesElementType {
        pub configurations: ProjectInstancesConfigurationsElementType,
    }
    impl WithDeserializer for ProjectInstancesElementType {
        type Deserializer = Box<quick_xml_deserialize::ProjectInstancesElementTypeDeserializer>;
    }
    impl WithSerializer for ProjectInstancesElementType {
        type Serializer<'x> = quick_xml_serialize::ProjectInstancesElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::ProjectInstancesElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::ProjectInstancesElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("ProjectInstances"),
                is_root,
            })
        }
    }
    #[doc = "Value that can be represented as a single token string"]
    #[derive(Debug)]
    pub struct ValueSimpleValueElementType {
        pub value: Option<::std::string::String>,
    }
    impl WithDeserializer for ValueSimpleValueElementType {
        type Deserializer = Box<quick_xml_deserialize::ValueSimpleValueElementTypeDeserializer>;
    }
    impl WithSerializer for ValueSimpleValueElementType {
        type Serializer<'x> = quick_xml_serialize::ValueSimpleValueElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::ValueSimpleValueElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::ValueSimpleValueElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("ValueSimpleValue"),
                is_root,
            })
        }
    }
    #[doc = "Array value consisting of a list of occurrances - value"]
    #[doc = "pairs"]
    #[derive(Debug)]
    pub struct ValueArrayValueElementType {
        pub content: Vec<ValueArrayValueElementTypeContent>,
    }
    #[doc = "Array value consisting of a list of occurrances - value"]
    #[doc = "pairs"]
    #[derive(Debug)]
    pub struct ValueArrayValueElementTypeContent {
        pub value: ValueArrayValueValueElementType,
    }
    impl WithDeserializer for ValueArrayValueElementType {
        type Deserializer = Box<quick_xml_deserialize::ValueArrayValueElementTypeDeserializer>;
    }
    impl WithDeserializer for ValueArrayValueElementTypeContent {
        type Deserializer =
            Box<quick_xml_deserialize::ValueArrayValueElementTypeContentDeserializer>;
    }
    impl WithSerializer for ValueArrayValueElementType {
        type Serializer<'x> = quick_xml_serialize::ValueArrayValueElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::ValueArrayValueElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::ValueArrayValueElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("ValueArrayValue"),
                is_root,
            })
        }
    }
    impl WithSerializer for ValueArrayValueElementTypeContent {
        type Serializer<'x> = quick_xml_serialize::ValueArrayValueElementTypeContentSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            let _name = name;
            let _is_root = is_root;
            Ok (quick_xml_serialize :: ValueArrayValueElementTypeContentSerializer { value : self , state : Box :: new (quick_xml_serialize :: ValueArrayValueElementTypeContentSerializerState :: Init__) , })
        }
    }
    #[doc = "Struct value consisting of a list of member - value pairs"]
    #[derive(Debug)]
    pub struct ValueStructValueElementType {
        pub content: Vec<ValueStructValueElementTypeContent>,
    }
    #[doc = "Struct value consisting of a list of member - value pairs"]
    #[derive(Debug)]
    pub struct ValueStructValueElementTypeContent {
        pub value: ValueStructValueValueElementType,
    }
    impl WithDeserializer for ValueStructValueElementType {
        type Deserializer = Box<quick_xml_deserialize::ValueStructValueElementTypeDeserializer>;
    }
    impl WithDeserializer for ValueStructValueElementTypeContent {
        type Deserializer =
            Box<quick_xml_deserialize::ValueStructValueElementTypeContentDeserializer>;
    }
    impl WithSerializer for ValueStructValueElementType {
        type Serializer<'x> = quick_xml_serialize::ValueStructValueElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::ValueStructValueElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::ValueStructValueElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("ValueStructValue"),
                is_root,
            })
        }
    }
    impl WithSerializer for ValueStructValueElementTypeContent {
        type Serializer<'x> = quick_xml_serialize::ValueStructValueElementTypeContentSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            let _name = name;
            let _is_root = is_root;
            Ok (quick_xml_serialize :: ValueStructValueElementTypeContentSerializer { value : self , state : Box :: new (quick_xml_serialize :: ValueStructValueElementTypeContentSerializerState :: Init__) , })
        }
    }
    #[doc = "Declaration of a variable"]
    #[derive(Debug)]
    pub struct VarListPlainVariableElementType {
        pub name: ::std::string::String,
        pub address: Option<::std::string::String>,
        pub global_id: Option<::std::string::String>,
        pub type_: DataType,
        pub initial_value: Option<ValueType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for VarListPlainVariableElementType {
        type Deserializer = Box<quick_xml_deserialize::VarListPlainVariableElementTypeDeserializer>;
    }
    impl WithSerializer for VarListPlainVariableElementType {
        type Serializer<'x> = quick_xml_serialize::VarListPlainVariableElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(
                quick_xml_serialize::VarListPlainVariableElementTypeSerializer {
                    value: self,
                    state: Box::new(
                        quick_xml_serialize::VarListPlainVariableElementTypeSerializerState::Init__,
                    ),
                    name: name.unwrap_or("VarListPlainVariable"),
                    is_root,
                },
            )
        }
    }
    #[doc = "Declaration of an access variable"]
    #[derive(Debug)]
    pub struct VarListAccessAccessVariableElementType {
        #[doc = "Name that is visible to the communication partner"]
        pub alias: ::std::string::String,
        #[doc = "Variable name including instance path inside the"]
        #[doc = "configuration"]
        pub instance_path_and_name: ::std::string::String,
        pub direction: Option<AccessType>,
        pub type_: DataType,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for VarListAccessAccessVariableElementType {
        type Deserializer =
            Box<quick_xml_deserialize::VarListAccessAccessVariableElementTypeDeserializer>;
    }
    impl WithSerializer for VarListAccessAccessVariableElementType {
        type Serializer<'x> =
            quick_xml_serialize::VarListAccessAccessVariableElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: VarListAccessAccessVariableElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: VarListAccessAccessVariableElementTypeSerializerState :: Init__) , name : name . unwrap_or ("VarListAccessAccessVariable") , is_root , })
        }
    }
    #[doc = "Declaration of an access variable"]
    #[derive(Debug)]
    pub struct VarListConfigConfigVariableElementType {
        #[doc = "Variable name including instance path"]
        pub instance_path_and_name: ::std::string::String,
        pub address: Option<::std::string::String>,
        pub type_: DataType,
        pub initial_value: Option<ValueType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for VarListConfigConfigVariableElementType {
        type Deserializer =
            Box<quick_xml_deserialize::VarListConfigConfigVariableElementTypeDeserializer>;
    }
    impl WithSerializer for VarListConfigConfigVariableElementType {
        type Serializer<'x> =
            quick_xml_serialize::VarListConfigConfigVariableElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: VarListConfigConfigVariableElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: VarListConfigConfigVariableElementTypeSerializerState :: Init__) , name : name . unwrap_or ("VarListConfigConfigVariable") , is_root , })
        }
    }
    #[derive(Debug)]
    pub enum AddDataDataHandleUnknownType {
        Preserve,
        Discard,
        Implementation,
    }
    impl DeserializeBytes for AddDataDataHandleUnknownType {
        fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, Error>
        where
            R: DeserializeReader,
        {
            match bytes {
                b"preserve" => Ok(Self::Preserve),
                b"discard" => Ok(Self::Discard),
                b"implementation" => Ok(Self::Implementation),
                x => {
                    Err(reader
                        .map_error(ErrorKind::UnknownOrInvalidValue(RawByteStr::from_slice(x))))
                }
            }
        }
    }
    impl SerializeBytes for AddDataDataHandleUnknownType {
        fn serialize_bytes(&self) -> Result<Option<Cow<'_, str>>, Error> {
            match self {
                Self::Preserve => Ok(Some(Cow::Borrowed("preserve"))),
                Self::Discard => Ok(Some(Cow::Borrowed("discard"))),
                Self::Implementation => Ok(Some(Cow::Borrowed("implementation"))),
            }
        }
    }
    #[derive(Debug)]
    pub struct CommentElementType {
        pub local_id: ::core::primitive::u64,
        pub height: ::core::primitive::f64,
        pub width: ::core::primitive::f64,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub content: FormattedTextType,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for CommentElementType {
        type Deserializer = Box<quick_xml_deserialize::CommentElementTypeDeserializer>;
    }
    impl WithSerializer for CommentElementType {
        type Serializer<'x> = quick_xml_serialize::CommentElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::CommentElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::CommentElementTypeSerializerState::Init__),
                name: name.unwrap_or("Comment"),
                is_root,
            })
        }
    }
    #[doc = "Describes a graphical object representing a variable,"]
    #[doc = "literal or expression used as r-value"]
    #[derive(Debug)]
    pub struct ConnectorElementType {
        #[doc = "The operand is a valid iec variable e.g. avar[0]"]
        pub name: ::std::string::String,
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_in: Option<ConnectionPointInType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for ConnectorElementType {
        type Deserializer = Box<quick_xml_deserialize::ConnectorElementTypeDeserializer>;
    }
    impl WithSerializer for ConnectorElementType {
        type Serializer<'x> = quick_xml_serialize::ConnectorElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::ConnectorElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::ConnectorElementTypeSerializerState::Init__),
                name: name.unwrap_or("Connector"),
                is_root,
            })
        }
    }
    #[doc = "Describes a graphical object representing a variable,"]
    #[doc = "literal or expression used as r-value"]
    #[derive(Debug)]
    pub struct ContinuationElementType {
        #[doc = "The operand is a valid iec variable e.g. avar[0]"]
        pub name: ::std::string::String,
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_out: Option<ConnectionPointOutType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for ContinuationElementType {
        type Deserializer = Box<quick_xml_deserialize::ContinuationElementTypeDeserializer>;
    }
    impl WithSerializer for ContinuationElementType {
        type Serializer<'x> = quick_xml_serialize::ContinuationElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::ContinuationElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::ContinuationElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("Continuation"),
                is_root,
            })
        }
    }
    #[derive(Debug)]
    pub struct ActionBlockElementType {
        pub local_id: ::core::primitive::u64,
        pub negated: ::core::primitive::bool,
        pub width: Option<::core::primitive::f64>,
        pub height: Option<::core::primitive::f64>,
        #[doc = "Used to identify the order of execution. Also used to"]
        #[doc = "identify one special block if there are several blocks with the same"]
        #[doc = "name."]
        pub execution_order_id: Option<::core::primitive::u64>,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_in: Option<ConnectionPointInType>,
        pub action: Vec<ActionBlockActionElementType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl ActionBlockElementType {
        #[must_use]
        pub fn default_negated() -> ::core::primitive::bool {
            false
        }
    }
    impl WithDeserializer for ActionBlockElementType {
        type Deserializer = Box<quick_xml_deserialize::ActionBlockElementTypeDeserializer>;
    }
    impl WithSerializer for ActionBlockElementType {
        type Serializer<'x> = quick_xml_serialize::ActionBlockElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::ActionBlockElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::ActionBlockElementTypeSerializerState::Init__),
                name: name.unwrap_or("ActionBlock"),
                is_root,
            })
        }
    }
    #[doc = "Describes a graphical object representing a call"]
    #[doc = "statement"]
    #[derive(Debug)]
    pub struct VendorElementElementType {
        pub local_id: ::core::primitive::u64,
        pub width: Option<::core::primitive::f64>,
        pub height: Option<::core::primitive::f64>,
        #[doc = "Used to identify the order of execution. Also used to"]
        #[doc = "identify one special block if there are several blocks with the same"]
        #[doc = "name."]
        pub execution_order_id: Option<::core::primitive::u64>,
        pub global_id: Option<::std::string::String>,
        #[doc = "Anchor position of the box. Top left corner"]
        #[doc = "excluding the instance name."]
        pub position: PositionType,
        #[doc = "An alternative text to be displayed in generic"]
        #[doc = "representation of unknown elements."]
        pub alternative_text: FormattedTextType,
        #[doc = "The list of used input variables (consumers)"]
        pub input_variables: Option<BlockInputVariablesElementType>,
        #[doc = "The list of used inOut variables"]
        pub in_out_variables: Option<BlockInOutVariablesElementType>,
        #[doc = "The list of used output variables (producers)"]
        pub output_variables: Option<BlockOutputVariablesElementType>,
        #[doc = "Additional, vendor specific data for the element."]
        #[doc = "Also defines the vendor specific meaning of the element."]
        pub add_data: AddDataType,
    }
    impl WithDeserializer for VendorElementElementType {
        type Deserializer = Box<quick_xml_deserialize::VendorElementElementTypeDeserializer>;
    }
    impl WithSerializer for VendorElementElementType {
        type Serializer<'x> = quick_xml_serialize::VendorElementElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::VendorElementElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::VendorElementElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("VendorElement"),
                is_root,
            })
        }
    }
    #[doc = "Describes a graphical object representing a call"]
    #[doc = "statement"]
    #[derive(Debug)]
    pub struct BlockElementType {
        pub local_id: ::core::primitive::u64,
        pub width: Option<::core::primitive::f64>,
        pub height: Option<::core::primitive::f64>,
        pub type_name: ::std::string::String,
        pub instance_name: Option<::std::string::String>,
        #[doc = "Used to identify the order of execution. Also used to"]
        #[doc = "identify one special block if there are several blocks with the same"]
        #[doc = "name."]
        pub execution_order_id: Option<::core::primitive::u64>,
        pub global_id: Option<::std::string::String>,
        #[doc = "Anchor position of the box. Top left corner"]
        #[doc = "excluding the instance name."]
        pub position: PositionType,
        #[doc = "The list of used input variables (consumers)"]
        pub input_variables: BlockInputVariablesElementType,
        #[doc = "The list of used inOut variables"]
        pub in_out_variables: BlockInOutVariablesElementType,
        #[doc = "The list of used output variables (producers)"]
        pub output_variables: BlockOutputVariablesElementType,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for BlockElementType {
        type Deserializer = Box<quick_xml_deserialize::BlockElementTypeDeserializer>;
    }
    impl WithSerializer for BlockElementType {
        type Serializer<'x> = quick_xml_serialize::BlockElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::BlockElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::BlockElementTypeSerializerState::Init__),
                name: name.unwrap_or("Block"),
                is_root,
            })
        }
    }
    #[doc = "Describes a graphical object representing a variable,"]
    #[doc = "literal or expression used as r-value"]
    #[derive(Debug)]
    pub struct InVariableElementType {
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        pub execution_order_id: Option<::core::primitive::u64>,
        pub negated: ::core::primitive::bool,
        pub edge: EdgeModifierType,
        pub storage: StorageModifierType,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_out: Option<ConnectionPointOutType>,
        #[doc = "The operand is a valid iec variable e.g. avar[0]."]
        pub expression: ::std::string::String,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl InVariableElementType {
        #[must_use]
        pub fn default_negated() -> ::core::primitive::bool {
            false
        }
        #[must_use]
        pub fn default_edge() -> EdgeModifierType {
            EdgeModifierType::None
        }
        #[must_use]
        pub fn default_storage() -> StorageModifierType {
            StorageModifierType::None
        }
    }
    impl WithDeserializer for InVariableElementType {
        type Deserializer = Box<quick_xml_deserialize::InVariableElementTypeDeserializer>;
    }
    impl WithSerializer for InVariableElementType {
        type Serializer<'x> = quick_xml_serialize::InVariableElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::InVariableElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::InVariableElementTypeSerializerState::Init__),
                name: name.unwrap_or("InVariable"),
                is_root,
            })
        }
    }
    #[doc = "Describes a graphical object representing a variable or"]
    #[doc = "expression used as l-value"]
    #[derive(Debug)]
    pub struct OutVariableElementType {
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        pub execution_order_id: Option<::core::primitive::u64>,
        pub negated: ::core::primitive::bool,
        pub edge: EdgeModifierType,
        pub storage: StorageModifierType,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_in: Option<ConnectionPointInType>,
        #[doc = "The operand is a valid iec variable e.g. avar[0]."]
        pub expression: ::std::string::String,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl OutVariableElementType {
        #[must_use]
        pub fn default_negated() -> ::core::primitive::bool {
            false
        }
        #[must_use]
        pub fn default_edge() -> EdgeModifierType {
            EdgeModifierType::None
        }
        #[must_use]
        pub fn default_storage() -> StorageModifierType {
            StorageModifierType::None
        }
    }
    impl WithDeserializer for OutVariableElementType {
        type Deserializer = Box<quick_xml_deserialize::OutVariableElementTypeDeserializer>;
    }
    impl WithSerializer for OutVariableElementType {
        type Serializer<'x> = quick_xml_serialize::OutVariableElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::OutVariableElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::OutVariableElementTypeSerializerState::Init__),
                name: name.unwrap_or("OutVariable"),
                is_root,
            })
        }
    }
    #[doc = "Describes a graphical object representing a variable"]
    #[doc = "which can be used as l-value and r-value at the same time"]
    #[derive(Debug)]
    pub struct InOutVariableElementType {
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        pub execution_order_id: Option<::core::primitive::u64>,
        pub negated_in: ::core::primitive::bool,
        pub edge_in: EdgeModifierType,
        pub storage_in: StorageModifierType,
        pub negated_out: ::core::primitive::bool,
        pub edge_out: EdgeModifierType,
        pub storage_out: StorageModifierType,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_in: Option<ConnectionPointInType>,
        pub connection_point_out: Option<ConnectionPointOutType>,
        #[doc = "The operand is a valid iec variable e.g. avar[0]."]
        pub expression: ::std::string::String,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl InOutVariableElementType {
        #[must_use]
        pub fn default_negated_in() -> ::core::primitive::bool {
            false
        }
        #[must_use]
        pub fn default_edge_in() -> EdgeModifierType {
            EdgeModifierType::None
        }
        #[must_use]
        pub fn default_storage_in() -> StorageModifierType {
            StorageModifierType::None
        }
        #[must_use]
        pub fn default_negated_out() -> ::core::primitive::bool {
            false
        }
        #[must_use]
        pub fn default_edge_out() -> EdgeModifierType {
            EdgeModifierType::None
        }
        #[must_use]
        pub fn default_storage_out() -> StorageModifierType {
            StorageModifierType::None
        }
    }
    impl WithDeserializer for InOutVariableElementType {
        type Deserializer = Box<quick_xml_deserialize::InOutVariableElementTypeDeserializer>;
    }
    impl WithSerializer for InOutVariableElementType {
        type Serializer<'x> = quick_xml_serialize::InOutVariableElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::InOutVariableElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::InOutVariableElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("InOutVariable"),
                is_root,
            })
        }
    }
    #[doc = "Describes a graphical object representing a jump label"]
    #[derive(Debug)]
    pub struct LabelElementType {
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        pub label: ::std::string::String,
        pub execution_order_id: Option<::core::primitive::u64>,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for LabelElementType {
        type Deserializer = Box<quick_xml_deserialize::LabelElementTypeDeserializer>;
    }
    impl WithSerializer for LabelElementType {
        type Serializer<'x> = quick_xml_serialize::LabelElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::LabelElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::LabelElementTypeSerializerState::Init__),
                name: name.unwrap_or("Label"),
                is_root,
            })
        }
    }
    #[doc = "Describes a graphical object representing a jump"]
    #[doc = "statement"]
    #[derive(Debug)]
    pub struct JumpElementType {
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        pub label: ::std::string::String,
        pub execution_order_id: Option<::core::primitive::u64>,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_in: Option<ConnectionPointInType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for JumpElementType {
        type Deserializer = Box<quick_xml_deserialize::JumpElementTypeDeserializer>;
    }
    impl WithSerializer for JumpElementType {
        type Serializer<'x> = quick_xml_serialize::JumpElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::JumpElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::JumpElementTypeSerializerState::Init__),
                name: name.unwrap_or("Jump"),
                is_root,
            })
        }
    }
    #[doc = "Describes a graphical object representing areturn"]
    #[doc = "statement"]
    #[derive(Debug)]
    pub struct ReturnElementType {
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        pub execution_order_id: Option<::core::primitive::u64>,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_in: Option<ConnectionPointInType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for ReturnElementType {
        type Deserializer = Box<quick_xml_deserialize::ReturnElementTypeDeserializer>;
    }
    impl WithSerializer for ReturnElementType {
        type Serializer<'x> = quick_xml_serialize::ReturnElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::ReturnElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::ReturnElementTypeSerializerState::Init__),
                name: name.unwrap_or("Return"),
                is_root,
            })
        }
    }
    #[doc = "Describes a graphical object representing a left"]
    #[doc = "powerrail"]
    #[derive(Debug)]
    pub struct LeftPowerRailElementType {
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        #[doc = "Used to identify the order of execution. Also used to"]
        #[doc = "identify one special block if there are several blocks with the same"]
        #[doc = "name."]
        pub execution_order_id: Option<::core::primitive::u64>,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_out: Vec<LeftPowerRailConnectionPointOutElementType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for LeftPowerRailElementType {
        type Deserializer = Box<quick_xml_deserialize::LeftPowerRailElementTypeDeserializer>;
    }
    impl WithSerializer for LeftPowerRailElementType {
        type Serializer<'x> = quick_xml_serialize::LeftPowerRailElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::LeftPowerRailElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::LeftPowerRailElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("LeftPowerRail"),
                is_root,
            })
        }
    }
    #[doc = "Describes a graphical object representing a right"]
    #[doc = "powerrail"]
    #[derive(Debug)]
    pub struct RightPowerRailElementType {
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        #[doc = "Used to identify the order of execution. Also used to"]
        #[doc = "identify one special block if there are several blocks with the same"]
        #[doc = "name."]
        pub execution_order_id: Option<::core::primitive::u64>,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_in: Vec<ConnectionPointInType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for RightPowerRailElementType {
        type Deserializer = Box<quick_xml_deserialize::RightPowerRailElementTypeDeserializer>;
    }
    impl WithSerializer for RightPowerRailElementType {
        type Serializer<'x> = quick_xml_serialize::RightPowerRailElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::RightPowerRailElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::RightPowerRailElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("RightPowerRail"),
                is_root,
            })
        }
    }
    #[doc = "Describes a graphical object representing a boolean"]
    #[doc = "variable which can be used as l-value and r-value at the same time"]
    #[derive(Debug)]
    pub struct CoilElementType {
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        pub execution_order_id: Option<::core::primitive::u64>,
        pub negated: ::core::primitive::bool,
        pub edge: EdgeModifierType,
        pub storage: StorageModifierType,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_in: Option<ConnectionPointInType>,
        pub connection_point_out: Option<ConnectionPointOutType>,
        #[doc = "The operand is a valid boolean iec variable e.g."]
        #[doc = "avar[0]"]
        pub variable: ::std::string::String,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl CoilElementType {
        #[must_use]
        pub fn default_negated() -> ::core::primitive::bool {
            false
        }
        #[must_use]
        pub fn default_edge() -> EdgeModifierType {
            EdgeModifierType::None
        }
        #[must_use]
        pub fn default_storage() -> StorageModifierType {
            StorageModifierType::None
        }
    }
    impl WithDeserializer for CoilElementType {
        type Deserializer = Box<quick_xml_deserialize::CoilElementTypeDeserializer>;
    }
    impl WithSerializer for CoilElementType {
        type Serializer<'x> = quick_xml_serialize::CoilElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::CoilElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::CoilElementTypeSerializerState::Init__),
                name: name.unwrap_or("Coil"),
                is_root,
            })
        }
    }
    #[doc = "Contains actions"]
    #[derive(Debug)]
    pub struct StepElementType {
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        pub name: ::std::string::String,
        pub initial_step: ::core::primitive::bool,
        pub negated: ::core::primitive::bool,
        #[doc = "Used to identify the order of execution. Also used to"]
        #[doc = "identify one special block if there are several blocks with the same"]
        #[doc = "name."]
        pub execution_order_id: Option<::core::primitive::u64>,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_in: Option<ConnectionPointInType>,
        pub connection_point_out: Option<LeftPowerRailConnectionPointOutElementType>,
        pub connection_point_out_action: Option<LeftPowerRailConnectionPointOutElementType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl StepElementType {
        #[must_use]
        pub fn default_initial_step() -> ::core::primitive::bool {
            false
        }
        #[must_use]
        pub fn default_negated() -> ::core::primitive::bool {
            false
        }
    }
    impl WithDeserializer for StepElementType {
        type Deserializer = Box<quick_xml_deserialize::StepElementTypeDeserializer>;
    }
    impl WithSerializer for StepElementType {
        type Serializer<'x> = quick_xml_serialize::StepElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::StepElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::StepElementTypeSerializerState::Init__),
                name: name.unwrap_or("Step"),
                is_root,
            })
        }
    }
    #[derive(Debug)]
    pub struct MacroStepElementType {
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        pub name: Option<::std::string::String>,
        #[doc = "Used to identify the order of execution. Also used to"]
        #[doc = "identify one special block if there are several blocks with the same"]
        #[doc = "name."]
        pub execution_order_id: Option<::core::primitive::u64>,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_in: Option<ConnectionPointInType>,
        pub connection_point_out: Option<ConnectionPointOutType>,
        pub body: Option<BodyType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for MacroStepElementType {
        type Deserializer = Box<quick_xml_deserialize::MacroStepElementTypeDeserializer>;
    }
    impl WithSerializer for MacroStepElementType {
        type Serializer<'x> = quick_xml_serialize::MacroStepElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::MacroStepElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::MacroStepElementTypeSerializerState::Init__),
                name: name.unwrap_or("MacroStep"),
                is_root,
            })
        }
    }
    #[derive(Debug)]
    pub struct JumpStepElementType {
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        pub target_name: ::std::string::String,
        #[doc = "Used to identify the order of execution. Also used to"]
        #[doc = "identify one special block if there are several blocks with the same"]
        #[doc = "name."]
        pub execution_order_id: Option<::core::primitive::u64>,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_in: Option<ConnectionPointInType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for JumpStepElementType {
        type Deserializer = Box<quick_xml_deserialize::JumpStepElementTypeDeserializer>;
    }
    impl WithSerializer for JumpStepElementType {
        type Serializer<'x> = quick_xml_serialize::JumpStepElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::JumpStepElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::JumpStepElementTypeSerializerState::Init__),
                name: name.unwrap_or("JumpStep"),
                is_root,
            })
        }
    }
    #[derive(Debug)]
    pub struct TransitionElementType {
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        #[doc = "The priority of a transition is evaluated, if the"]
        #[doc = "transition is connected to a selectionDivergence element."]
        pub priority: Option<::core::primitive::u64>,
        #[doc = "Used to identify the order of execution. Also used to"]
        #[doc = "identify one special block if there are several blocks with the same"]
        #[doc = "name."]
        pub execution_order_id: Option<::core::primitive::u64>,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_in: Option<ConnectionPointInType>,
        pub connection_point_out: Option<ConnectionPointOutType>,
        pub condition: Option<TransitionConditionElementType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for TransitionElementType {
        type Deserializer = Box<quick_xml_deserialize::TransitionElementTypeDeserializer>;
    }
    impl WithSerializer for TransitionElementType {
        type Serializer<'x> = quick_xml_serialize::TransitionElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::TransitionElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::TransitionElementTypeSerializerState::Init__),
                name: name.unwrap_or("Transition"),
                is_root,
            })
        }
    }
    #[derive(Debug)]
    pub struct SelectionDivergenceElementType {
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_in: Option<ConnectionPointInType>,
        pub connection_point_out: Vec<LeftPowerRailConnectionPointOutElementType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for SelectionDivergenceElementType {
        type Deserializer = Box<quick_xml_deserialize::SelectionDivergenceElementTypeDeserializer>;
    }
    impl WithSerializer for SelectionDivergenceElementType {
        type Serializer<'x> = quick_xml_serialize::SelectionDivergenceElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(
                quick_xml_serialize::SelectionDivergenceElementTypeSerializer {
                    value: self,
                    state: Box::new(
                        quick_xml_serialize::SelectionDivergenceElementTypeSerializerState::Init__,
                    ),
                    name: name.unwrap_or("SelectionDivergence"),
                    is_root,
                },
            )
        }
    }
    #[derive(Debug)]
    pub struct SelectionConvergenceElementType {
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_in: Vec<SelectionConvergenceConnectionPointInElementType>,
        pub connection_point_out: Option<ConnectionPointOutType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for SelectionConvergenceElementType {
        type Deserializer = Box<quick_xml_deserialize::SelectionConvergenceElementTypeDeserializer>;
    }
    impl WithSerializer for SelectionConvergenceElementType {
        type Serializer<'x> = quick_xml_serialize::SelectionConvergenceElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(
                quick_xml_serialize::SelectionConvergenceElementTypeSerializer {
                    value: self,
                    state: Box::new(
                        quick_xml_serialize::SelectionConvergenceElementTypeSerializerState::Init__,
                    ),
                    name: name.unwrap_or("SelectionConvergence"),
                    is_root,
                },
            )
        }
    }
    #[derive(Debug)]
    pub struct SimultaneousDivergenceElementType {
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        pub name: Option<::std::string::String>,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_in: Option<ConnectionPointInType>,
        pub connection_point_out: Vec<LeftPowerRailConnectionPointOutElementType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for SimultaneousDivergenceElementType {
        type Deserializer =
            Box<quick_xml_deserialize::SimultaneousDivergenceElementTypeDeserializer>;
    }
    impl WithSerializer for SimultaneousDivergenceElementType {
        type Serializer<'x> = quick_xml_serialize::SimultaneousDivergenceElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: SimultaneousDivergenceElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: SimultaneousDivergenceElementTypeSerializerState :: Init__) , name : name . unwrap_or ("SimultaneousDivergence") , is_root , })
        }
    }
    #[derive(Debug)]
    pub struct SimultaneousConvergenceElementType {
        pub local_id: ::core::primitive::u64,
        pub height: Option<::core::primitive::f64>,
        pub width: Option<::core::primitive::f64>,
        pub global_id: Option<::std::string::String>,
        pub position: PositionType,
        pub connection_point_in: Vec<ConnectionPointInType>,
        pub connection_point_out: Option<ConnectionPointOutType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for SimultaneousConvergenceElementType {
        type Deserializer =
            Box<quick_xml_deserialize::SimultaneousConvergenceElementTypeDeserializer>;
    }
    impl WithSerializer for SimultaneousConvergenceElementType {
        type Serializer<'x> = quick_xml_serialize::SimultaneousConvergenceElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: SimultaneousConvergenceElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: SimultaneousConvergenceElementTypeSerializerState :: Init__) , name : name . unwrap_or ("SimultaneousConvergence") , is_root , })
        }
    }
    #[derive(Debug)]
    pub struct EnumValuesElementType {
        pub content: Vec<EnumValuesElementTypeContent>,
    }
    #[derive(Debug)]
    pub struct EnumValuesElementTypeContent {
        pub value: EnumValuesValueElementType,
    }
    impl WithDeserializer for EnumValuesElementType {
        type Deserializer = Box<quick_xml_deserialize::EnumValuesElementTypeDeserializer>;
    }
    impl WithDeserializer for EnumValuesElementTypeContent {
        type Deserializer = Box<quick_xml_deserialize::EnumValuesElementTypeContentDeserializer>;
    }
    impl WithSerializer for EnumValuesElementType {
        type Serializer<'x> = quick_xml_serialize::EnumValuesElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::EnumValuesElementTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::EnumValuesElementTypeSerializerState::Init__),
                name: name.unwrap_or("EnumValues"),
                is_root,
            })
        }
    }
    impl WithSerializer for EnumValuesElementTypeContent {
        type Serializer<'x> = quick_xml_serialize::EnumValuesElementTypeContentSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            let _name = name;
            let _is_root = is_root;
            Ok(
                quick_xml_serialize::EnumValuesElementTypeContentSerializer {
                    value: self,
                    state: Box::new(
                        quick_xml_serialize::EnumValuesElementTypeContentSerializerState::Init__,
                    ),
                },
            )
        }
    }
    #[derive(Debug)]
    pub struct ProjectContentHeaderCoordinateInfoElementType {
        pub page_size: Option<PositionType>,
        pub fbd: ProjectContentHeaderCoordinateInfoFbdElementType,
        pub ld: ProjectContentHeaderCoordinateInfoFbdElementType,
        pub sfc: ProjectContentHeaderCoordinateInfoFbdElementType,
    }
    impl WithDeserializer for ProjectContentHeaderCoordinateInfoElementType {
        type Deserializer =
            Box<quick_xml_deserialize::ProjectContentHeaderCoordinateInfoElementTypeDeserializer>;
    }
    impl WithSerializer for ProjectContentHeaderCoordinateInfoElementType {
        type Serializer<'x> =
            quick_xml_serialize::ProjectContentHeaderCoordinateInfoElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: ProjectContentHeaderCoordinateInfoElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: ProjectContentHeaderCoordinateInfoElementTypeSerializerState :: Init__) , name : name . unwrap_or ("ProjectContentHeaderCoordinateInfo") , is_root , })
        }
    }
    #[derive(Debug)]
    pub struct ProjectTypesDataTypesElementType {
        pub data_type: Vec<ProjectTypesDataTypesDataTypeElementType>,
    }
    impl WithDeserializer for ProjectTypesDataTypesElementType {
        type Deserializer =
            Box<quick_xml_deserialize::ProjectTypesDataTypesElementTypeDeserializer>;
    }
    impl WithSerializer for ProjectTypesDataTypesElementType {
        type Serializer<'x> = quick_xml_serialize::ProjectTypesDataTypesElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: ProjectTypesDataTypesElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: ProjectTypesDataTypesElementTypeSerializerState :: Init__) , name : name . unwrap_or ("ProjectTypesDataTypes") , is_root , })
        }
    }
    #[derive(Debug)]
    pub struct ProjectTypesPousElementType {
        pub pou: Vec<ProjectTypesPousPouElementType>,
    }
    impl WithDeserializer for ProjectTypesPousElementType {
        type Deserializer = Box<quick_xml_deserialize::ProjectTypesPousElementTypeDeserializer>;
    }
    impl WithSerializer for ProjectTypesPousElementType {
        type Serializer<'x> = quick_xml_serialize::ProjectTypesPousElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::ProjectTypesPousElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::ProjectTypesPousElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("ProjectTypesPous"),
                is_root,
            })
        }
    }
    #[derive(Debug)]
    pub struct ProjectInstancesConfigurationsElementType {
        pub configuration: Vec<ProjectInstancesConfigurationsConfigurationElementType>,
    }
    impl WithDeserializer for ProjectInstancesConfigurationsElementType {
        type Deserializer =
            Box<quick_xml_deserialize::ProjectInstancesConfigurationsElementTypeDeserializer>;
    }
    impl WithSerializer for ProjectInstancesConfigurationsElementType {
        type Serializer<'x> =
            quick_xml_serialize::ProjectInstancesConfigurationsElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: ProjectInstancesConfigurationsElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: ProjectInstancesConfigurationsElementTypeSerializerState :: Init__) , name : name . unwrap_or ("ProjectInstancesConfigurations") , is_root , })
        }
    }
    #[derive(Debug)]
    pub struct ValueArrayValueValueElementType {
        pub repetition_value: ::std::string::String,
        pub content: ValueArrayValueValueElementTypeContent,
    }
    #[derive(Debug)]
    pub enum ValueArrayValueValueElementTypeContent {
        SimpleValue(ValueSimpleValueElementType),
        ArrayValue(ValueArrayValueElementType),
        StructValue(ValueStructValueElementType),
    }
    impl ValueArrayValueValueElementType {
        #[must_use]
        pub fn default_repetition_value() -> ::std::string::String {
            String::from("1")
        }
    }
    impl WithDeserializer for ValueArrayValueValueElementType {
        type Deserializer = Box<quick_xml_deserialize::ValueArrayValueValueElementTypeDeserializer>;
    }
    impl WithDeserializer for ValueArrayValueValueElementTypeContent {
        type Deserializer =
            Box<quick_xml_deserialize::ValueArrayValueValueElementTypeContentDeserializer>;
    }
    impl WithSerializer for ValueArrayValueValueElementType {
        type Serializer<'x> = quick_xml_serialize::ValueArrayValueValueElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(
                quick_xml_serialize::ValueArrayValueValueElementTypeSerializer {
                    value: self,
                    state: Box::new(
                        quick_xml_serialize::ValueArrayValueValueElementTypeSerializerState::Init__,
                    ),
                    name: name.unwrap_or("ValueArrayValueValue"),
                    is_root,
                },
            )
        }
    }
    impl WithSerializer for ValueArrayValueValueElementTypeContent {
        type Serializer<'x> =
            quick_xml_serialize::ValueArrayValueValueElementTypeContentSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            let _name = name;
            let _is_root = is_root;
            Ok (quick_xml_serialize :: ValueArrayValueValueElementTypeContentSerializer { value : self , state : Box :: new (quick_xml_serialize :: ValueArrayValueValueElementTypeContentSerializerState :: Init__) , })
        }
    }
    #[derive(Debug)]
    pub struct ValueStructValueValueElementType {
        pub member: ::std::string::String,
        pub content: ValueStructValueValueElementTypeContent,
    }
    #[derive(Debug)]
    pub enum ValueStructValueValueElementTypeContent {
        SimpleValue(ValueSimpleValueElementType),
        ArrayValue(ValueArrayValueElementType),
        StructValue(ValueStructValueElementType),
    }
    impl WithDeserializer for ValueStructValueValueElementType {
        type Deserializer =
            Box<quick_xml_deserialize::ValueStructValueValueElementTypeDeserializer>;
    }
    impl WithDeserializer for ValueStructValueValueElementTypeContent {
        type Deserializer =
            Box<quick_xml_deserialize::ValueStructValueValueElementTypeContentDeserializer>;
    }
    impl WithSerializer for ValueStructValueValueElementType {
        type Serializer<'x> = quick_xml_serialize::ValueStructValueValueElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: ValueStructValueValueElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: ValueStructValueValueElementTypeSerializerState :: Init__) , name : name . unwrap_or ("ValueStructValueValue") , is_root , })
        }
    }
    impl WithSerializer for ValueStructValueValueElementTypeContent {
        type Serializer<'x> =
            quick_xml_serialize::ValueStructValueValueElementTypeContentSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            let _name = name;
            let _is_root = is_root;
            Ok (quick_xml_serialize :: ValueStructValueValueElementTypeContentSerializer { value : self , state : Box :: new (quick_xml_serialize :: ValueStructValueValueElementTypeContentSerializerState :: Init__) , })
        }
    }
    #[doc = "Association of an action with qualifier"]
    #[derive(Debug)]
    pub struct ActionBlockActionElementType {
        pub local_id: ::core::primitive::u64,
        pub qualifier: ActionBlockActionQualifierType,
        pub width: Option<::core::primitive::f64>,
        pub height: Option<::core::primitive::f64>,
        pub duration: Option<::std::string::String>,
        pub indicator: Option<::std::string::String>,
        #[doc = "Used to identify the order of execution."]
        #[doc = "Also used to identify one special block if there are"]
        #[doc = "several blocks with the same name."]
        pub execution_order_id: Option<::core::primitive::u64>,
        pub global_id: Option<::std::string::String>,
        #[doc = "Relative position of the action."]
        #[doc = "Origin is the anchor position of the action block."]
        pub rel_position: PositionType,
        #[doc = "Name of an action or boolean"]
        #[doc = "variable."]
        pub reference: Option<ActionBlockActionReferenceElementType>,
        #[doc = "Inline implementation of an action"]
        #[doc = "body."]
        pub inline: Option<BodyType>,
        pub connection_point_out: Option<ConnectionPointOutType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl ActionBlockActionElementType {
        #[must_use]
        pub fn default_qualifier() -> ActionBlockActionQualifierType {
            ActionBlockActionQualifierType::N
        }
    }
    impl WithDeserializer for ActionBlockActionElementType {
        type Deserializer = Box<quick_xml_deserialize::ActionBlockActionElementTypeDeserializer>;
    }
    impl WithSerializer for ActionBlockActionElementType {
        type Serializer<'x> = quick_xml_serialize::ActionBlockActionElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(
                quick_xml_serialize::ActionBlockActionElementTypeSerializer {
                    value: self,
                    state: Box::new(
                        quick_xml_serialize::ActionBlockActionElementTypeSerializerState::Init__,
                    ),
                    name: name.unwrap_or("ActionBlockAction"),
                    is_root,
                },
            )
        }
    }
    #[derive(Debug)]
    pub struct BlockInputVariablesElementType {
        pub variable: Vec<BlockInputVariablesVariableElementType>,
    }
    impl WithDeserializer for BlockInputVariablesElementType {
        type Deserializer = Box<quick_xml_deserialize::BlockInputVariablesElementTypeDeserializer>;
    }
    impl WithSerializer for BlockInputVariablesElementType {
        type Serializer<'x> = quick_xml_serialize::BlockInputVariablesElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(
                quick_xml_serialize::BlockInputVariablesElementTypeSerializer {
                    value: self,
                    state: Box::new(
                        quick_xml_serialize::BlockInputVariablesElementTypeSerializerState::Init__,
                    ),
                    name: name.unwrap_or("BlockInputVariables"),
                    is_root,
                },
            )
        }
    }
    #[derive(Debug)]
    pub struct BlockInOutVariablesElementType {
        pub variable: Vec<BlockInOutVariablesVariableElementType>,
    }
    impl WithDeserializer for BlockInOutVariablesElementType {
        type Deserializer = Box<quick_xml_deserialize::BlockInOutVariablesElementTypeDeserializer>;
    }
    impl WithSerializer for BlockInOutVariablesElementType {
        type Serializer<'x> = quick_xml_serialize::BlockInOutVariablesElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(
                quick_xml_serialize::BlockInOutVariablesElementTypeSerializer {
                    value: self,
                    state: Box::new(
                        quick_xml_serialize::BlockInOutVariablesElementTypeSerializerState::Init__,
                    ),
                    name: name.unwrap_or("BlockInOutVariables"),
                    is_root,
                },
            )
        }
    }
    #[derive(Debug)]
    pub struct BlockOutputVariablesElementType {
        pub variable: Vec<BlockOutputVariablesVariableElementType>,
    }
    impl WithDeserializer for BlockOutputVariablesElementType {
        type Deserializer = Box<quick_xml_deserialize::BlockOutputVariablesElementTypeDeserializer>;
    }
    impl WithSerializer for BlockOutputVariablesElementType {
        type Serializer<'x> = quick_xml_serialize::BlockOutputVariablesElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(
                quick_xml_serialize::BlockOutputVariablesElementTypeSerializer {
                    value: self,
                    state: Box::new(
                        quick_xml_serialize::BlockOutputVariablesElementTypeSerializerState::Init__,
                    ),
                    name: name.unwrap_or("BlockOutputVariables"),
                    is_root,
                },
            )
        }
    }
    #[derive(Debug)]
    pub struct LeftPowerRailConnectionPointOutElementType {
        pub global_id: Option<::std::string::String>,
        pub formal_parameter: ::std::string::String,
        #[doc = "Relative position of the connection pin. Origin is the anchor"]
        #[doc = "position of the block."]
        pub rel_position: Option<PositionType>,
        #[doc = "The operand is a valid iec variable e.g. avar[0]."]
        pub expression: Option<::std::string::String>,
        pub add_data: Option<AddDataType>,
    }
    impl WithDeserializer for LeftPowerRailConnectionPointOutElementType {
        type Deserializer =
            Box<quick_xml_deserialize::LeftPowerRailConnectionPointOutElementTypeDeserializer>;
    }
    impl WithSerializer for LeftPowerRailConnectionPointOutElementType {
        type Serializer<'x> =
            quick_xml_serialize::LeftPowerRailConnectionPointOutElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: LeftPowerRailConnectionPointOutElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: LeftPowerRailConnectionPointOutElementTypeSerializerState :: Init__) , name : name . unwrap_or ("LeftPowerRailConnectionPointOut") , is_root , })
        }
    }
    #[derive(Debug)]
    pub struct TransitionConditionElementType {
        pub negated: ::core::primitive::bool,
        pub content: TransitionConditionElementTypeContent,
    }
    #[derive(Debug)]
    pub enum TransitionConditionElementTypeContent {
        Reference(ActionBlockActionReferenceElementType),
        ConnectionPointIn(ConnectionPointInType),
        Inline(TransitionConditionInlineElementType),
    }
    impl TransitionConditionElementType {
        #[must_use]
        pub fn default_negated() -> ::core::primitive::bool {
            false
        }
    }
    impl WithDeserializer for TransitionConditionElementType {
        type Deserializer = Box<quick_xml_deserialize::TransitionConditionElementTypeDeserializer>;
    }
    impl WithDeserializer for TransitionConditionElementTypeContent {
        type Deserializer =
            Box<quick_xml_deserialize::TransitionConditionElementTypeContentDeserializer>;
    }
    impl WithSerializer for TransitionConditionElementType {
        type Serializer<'x> = quick_xml_serialize::TransitionConditionElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(
                quick_xml_serialize::TransitionConditionElementTypeSerializer {
                    value: self,
                    state: Box::new(
                        quick_xml_serialize::TransitionConditionElementTypeSerializerState::Init__,
                    ),
                    name: name.unwrap_or("TransitionCondition"),
                    is_root,
                },
            )
        }
    }
    impl WithSerializer for TransitionConditionElementTypeContent {
        type Serializer<'x> =
            quick_xml_serialize::TransitionConditionElementTypeContentSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            let _name = name;
            let _is_root = is_root;
            Ok (quick_xml_serialize :: TransitionConditionElementTypeContentSerializer { value : self , state : Box :: new (quick_xml_serialize :: TransitionConditionElementTypeContentSerializerState :: Init__) , })
        }
    }
    #[derive(Debug)]
    pub struct SelectionConvergenceConnectionPointInElementType {
        pub global_id: Option<::std::string::String>,
        pub content: Vec<SelectionConvergenceConnectionPointInElementTypeContent>,
    }
    #[derive(Debug)]
    pub enum SelectionConvergenceConnectionPointInElementTypeContent {
        #[doc = "Relative position of the connection pin. Origin is the anchor"]
        #[doc = "position of the block."]
        RelPosition(PositionType),
        Connection(ConnectionType),
        #[doc = "The operand is a valid iec variable e.g. avar[0] or an"]
        #[doc = "iec expression or multiple token text e.g. a + b (*sum*). An iec 61131-3"]
        #[doc = "parser has to be used to extract variable information."]
        Expression(::std::string::String),
        AddData(AddDataType),
    }
    impl WithDeserializer for SelectionConvergenceConnectionPointInElementType {
        type Deserializer = Box<
            quick_xml_deserialize::SelectionConvergenceConnectionPointInElementTypeDeserializer,
        >;
    }
    impl WithDeserializer for SelectionConvergenceConnectionPointInElementTypeContent {
        type Deserializer = Box < quick_xml_deserialize :: SelectionConvergenceConnectionPointInElementTypeContentDeserializer > ;
    }
    impl WithSerializer for SelectionConvergenceConnectionPointInElementType {
        type Serializer<'x> =
            quick_xml_serialize::SelectionConvergenceConnectionPointInElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: SelectionConvergenceConnectionPointInElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: SelectionConvergenceConnectionPointInElementTypeSerializerState :: Init__) , name : name . unwrap_or ("SelectionConvergenceConnectionPointIn") , is_root , })
        }
    }
    impl WithSerializer for SelectionConvergenceConnectionPointInElementTypeContent {
        type Serializer<'x> =
            quick_xml_serialize::SelectionConvergenceConnectionPointInElementTypeContentSerializer<
                'x,
            >;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            let _name = name;
            let _is_root = is_root;
            Ok (quick_xml_serialize :: SelectionConvergenceConnectionPointInElementTypeContentSerializer { value : self , state : Box :: new (quick_xml_serialize :: SelectionConvergenceConnectionPointInElementTypeContentSerializerState :: Init__) , })
        }
    }
    #[doc = "An enumeration value used to"]
    #[doc = "build up enumeration types"]
    #[derive(Debug)]
    pub struct EnumValuesValueElementType {
        pub name: ::std::string::String,
        pub value: Option<::std::string::String>,
    }
    impl WithDeserializer for EnumValuesValueElementType {
        type Deserializer = Box<quick_xml_deserialize::EnumValuesValueElementTypeDeserializer>;
    }
    impl WithSerializer for EnumValuesValueElementType {
        type Serializer<'x> = quick_xml_serialize::EnumValuesValueElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::EnumValuesValueElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::EnumValuesValueElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("EnumValuesValue"),
                is_root,
            })
        }
    }
    #[derive(Debug)]
    pub struct ProjectContentHeaderCoordinateInfoFbdElementType {
        pub scaling: PositionType,
    }
    impl WithDeserializer for ProjectContentHeaderCoordinateInfoFbdElementType {
        type Deserializer = Box<
            quick_xml_deserialize::ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializer,
        >;
    }
    impl WithSerializer for ProjectContentHeaderCoordinateInfoFbdElementType {
        type Serializer<'x> =
            quick_xml_serialize::ProjectContentHeaderCoordinateInfoFbdElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: ProjectContentHeaderCoordinateInfoFbdElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: ProjectContentHeaderCoordinateInfoFbdElementTypeSerializerState :: Init__) , name : name . unwrap_or ("ProjectContentHeaderCoordinateInfoFbd") , is_root , })
        }
    }
    #[derive(Debug)]
    pub struct ProjectTypesDataTypesDataTypeElementType {
        pub name: ::std::string::String,
        pub base_type: DataType,
        pub initial_value: Option<ValueType>,
        pub add_data: Option<AddDataType>,
        #[doc = "Additional"]
        #[doc = "userspecific information to the"]
        #[doc = "element"]
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for ProjectTypesDataTypesDataTypeElementType {
        type Deserializer =
            Box<quick_xml_deserialize::ProjectTypesDataTypesDataTypeElementTypeDeserializer>;
    }
    impl WithSerializer for ProjectTypesDataTypesDataTypeElementType {
        type Serializer<'x> =
            quick_xml_serialize::ProjectTypesDataTypesDataTypeElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: ProjectTypesDataTypesDataTypeElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: ProjectTypesDataTypesDataTypeElementTypeSerializerState :: Init__) , name : name . unwrap_or ("ProjectTypesDataTypesDataType") , is_root , })
        }
    }
    #[derive(Debug)]
    pub struct ProjectTypesPousPouElementType {
        pub name: ::std::string::String,
        pub pou_type: PouType,
        pub global_id: Option<::std::string::String>,
        pub interface: Option<ProjectTypesPousPouInterfaceElementType>,
        pub actions: Option<ProjectTypesPousPouActionsElementType>,
        pub transitions: Option<ProjectTypesPousPouTransitionsElementType>,
        pub body: Vec<BodyType>,
        pub add_data: Option<AddDataType>,
        #[doc = "Additional"]
        #[doc = "userspecific information to the"]
        #[doc = "element"]
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for ProjectTypesPousPouElementType {
        type Deserializer = Box<quick_xml_deserialize::ProjectTypesPousPouElementTypeDeserializer>;
    }
    impl WithSerializer for ProjectTypesPousPouElementType {
        type Serializer<'x> = quick_xml_serialize::ProjectTypesPousPouElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(
                quick_xml_serialize::ProjectTypesPousPouElementTypeSerializer {
                    value: self,
                    state: Box::new(
                        quick_xml_serialize::ProjectTypesPousPouElementTypeSerializerState::Init__,
                    ),
                    name: name.unwrap_or("ProjectTypesPousPou"),
                    is_root,
                },
            )
        }
    }
    #[doc = "Represents a group of"]
    #[doc = "resources and global variables"]
    #[derive(Debug)]
    pub struct ProjectInstancesConfigurationsConfigurationElementType {
        pub name: ::std::string::String,
        pub global_id: Option<::std::string::String>,
        pub resource: Vec<ProjectInstancesConfigurationsConfigurationResourceElementType>,
        pub global_vars: Vec<VarListType>,
        pub access_vars: Option<VarListAccessType>,
        pub config_vars: Option<VarListConfigType>,
        pub add_data: Option<AddDataType>,
        #[doc = "Additional"]
        #[doc = "userspecific information to the"]
        #[doc = "element"]
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for ProjectInstancesConfigurationsConfigurationElementType {
        type Deserializer = Box < quick_xml_deserialize :: ProjectInstancesConfigurationsConfigurationElementTypeDeserializer > ;
    }
    impl WithSerializer for ProjectInstancesConfigurationsConfigurationElementType {
        type Serializer<'x> =
            quick_xml_serialize::ProjectInstancesConfigurationsConfigurationElementTypeSerializer<
                'x,
            >;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: ProjectInstancesConfigurationsConfigurationElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: Init__) , name : name . unwrap_or ("ProjectInstancesConfigurationsConfiguration") , is_root , })
        }
    }
    #[derive(Debug)]
    pub enum ActionBlockActionQualifierType {
        P1,
        N,
        P0,
        R,
        S,
        L,
        D,
        P,
        Ds,
        Dl,
        Sd,
        Sl,
    }
    impl DeserializeBytes for ActionBlockActionQualifierType {
        fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, Error>
        where
            R: DeserializeReader,
        {
            match bytes {
                b"P1" => Ok(Self::P1),
                b"N" => Ok(Self::N),
                b"P0" => Ok(Self::P0),
                b"R" => Ok(Self::R),
                b"S" => Ok(Self::S),
                b"L" => Ok(Self::L),
                b"D" => Ok(Self::D),
                b"P" => Ok(Self::P),
                b"DS" => Ok(Self::Ds),
                b"DL" => Ok(Self::Dl),
                b"SD" => Ok(Self::Sd),
                b"SL" => Ok(Self::Sl),
                x => {
                    Err(reader
                        .map_error(ErrorKind::UnknownOrInvalidValue(RawByteStr::from_slice(x))))
                }
            }
        }
    }
    impl SerializeBytes for ActionBlockActionQualifierType {
        fn serialize_bytes(&self) -> Result<Option<Cow<'_, str>>, Error> {
            match self {
                Self::P1 => Ok(Some(Cow::Borrowed("P1"))),
                Self::N => Ok(Some(Cow::Borrowed("N"))),
                Self::P0 => Ok(Some(Cow::Borrowed("P0"))),
                Self::R => Ok(Some(Cow::Borrowed("R"))),
                Self::S => Ok(Some(Cow::Borrowed("S"))),
                Self::L => Ok(Some(Cow::Borrowed("L"))),
                Self::D => Ok(Some(Cow::Borrowed("D"))),
                Self::P => Ok(Some(Cow::Borrowed("P"))),
                Self::Ds => Ok(Some(Cow::Borrowed("DS"))),
                Self::Dl => Ok(Some(Cow::Borrowed("DL"))),
                Self::Sd => Ok(Some(Cow::Borrowed("SD"))),
                Self::Sl => Ok(Some(Cow::Borrowed("SL"))),
            }
        }
    }
    #[derive(Debug)]
    pub struct ActionBlockActionReferenceElementType {
        pub name: ::std::string::String,
    }
    impl WithDeserializer for ActionBlockActionReferenceElementType {
        type Deserializer =
            Box<quick_xml_deserialize::ActionBlockActionReferenceElementTypeDeserializer>;
    }
    impl WithSerializer for ActionBlockActionReferenceElementType {
        type Serializer<'x> =
            quick_xml_serialize::ActionBlockActionReferenceElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: ActionBlockActionReferenceElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: ActionBlockActionReferenceElementTypeSerializerState :: Init__) , name : name . unwrap_or ("ActionBlockActionReference") , is_root , })
        }
    }
    #[doc = "Describes an inputVariable of a"]
    #[doc = "Function or a FunctionBlock"]
    #[derive(Debug)]
    pub struct BlockInputVariablesVariableElementType {
        pub formal_parameter: ::std::string::String,
        pub negated: ::core::primitive::bool,
        pub edge: EdgeModifierType,
        pub storage: StorageModifierType,
        pub hidden: ::core::primitive::bool,
        pub connection_point_in: ConnectionPointInType,
        pub documentation: Option<FormattedTextType>,
    }
    impl BlockInputVariablesVariableElementType {
        #[must_use]
        pub fn default_negated() -> ::core::primitive::bool {
            false
        }
        #[must_use]
        pub fn default_edge() -> EdgeModifierType {
            EdgeModifierType::None
        }
        #[must_use]
        pub fn default_storage() -> StorageModifierType {
            StorageModifierType::None
        }
        #[must_use]
        pub fn default_hidden() -> ::core::primitive::bool {
            false
        }
    }
    impl WithDeserializer for BlockInputVariablesVariableElementType {
        type Deserializer =
            Box<quick_xml_deserialize::BlockInputVariablesVariableElementTypeDeserializer>;
    }
    impl WithSerializer for BlockInputVariablesVariableElementType {
        type Serializer<'x> =
            quick_xml_serialize::BlockInputVariablesVariableElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: BlockInputVariablesVariableElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: BlockInputVariablesVariableElementTypeSerializerState :: Init__) , name : name . unwrap_or ("BlockInputVariablesVariable") , is_root , })
        }
    }
    #[doc = "Describes a inOutVariable of a"]
    #[doc = "Function or a FunctionBlock"]
    #[derive(Debug)]
    pub struct BlockInOutVariablesVariableElementType {
        pub formal_parameter: ::std::string::String,
        pub negated: ::core::primitive::bool,
        pub edge: EdgeModifierType,
        pub storage: StorageModifierType,
        pub hidden: ::core::primitive::bool,
        pub connection_point_in: Option<ConnectionPointInType>,
        pub connection_point_out: Option<ConnectionPointOutType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl BlockInOutVariablesVariableElementType {
        #[must_use]
        pub fn default_negated() -> ::core::primitive::bool {
            false
        }
        #[must_use]
        pub fn default_edge() -> EdgeModifierType {
            EdgeModifierType::None
        }
        #[must_use]
        pub fn default_storage() -> StorageModifierType {
            StorageModifierType::None
        }
        #[must_use]
        pub fn default_hidden() -> ::core::primitive::bool {
            false
        }
    }
    impl WithDeserializer for BlockInOutVariablesVariableElementType {
        type Deserializer =
            Box<quick_xml_deserialize::BlockInOutVariablesVariableElementTypeDeserializer>;
    }
    impl WithSerializer for BlockInOutVariablesVariableElementType {
        type Serializer<'x> =
            quick_xml_serialize::BlockInOutVariablesVariableElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: BlockInOutVariablesVariableElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: BlockInOutVariablesVariableElementTypeSerializerState :: Init__) , name : name . unwrap_or ("BlockInOutVariablesVariable") , is_root , })
        }
    }
    #[doc = "Describes a outputVariable of a"]
    #[doc = "Function or a FunctionBlock"]
    #[derive(Debug)]
    pub struct BlockOutputVariablesVariableElementType {
        pub formal_parameter: ::std::string::String,
        pub negated: ::core::primitive::bool,
        pub edge: EdgeModifierType,
        pub storage: StorageModifierType,
        pub hidden: ::core::primitive::bool,
        pub connection_point_out: Option<ConnectionPointOutType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl BlockOutputVariablesVariableElementType {
        #[must_use]
        pub fn default_negated() -> ::core::primitive::bool {
            false
        }
        #[must_use]
        pub fn default_edge() -> EdgeModifierType {
            EdgeModifierType::None
        }
        #[must_use]
        pub fn default_storage() -> StorageModifierType {
            StorageModifierType::None
        }
        #[must_use]
        pub fn default_hidden() -> ::core::primitive::bool {
            false
        }
    }
    impl WithDeserializer for BlockOutputVariablesVariableElementType {
        type Deserializer =
            Box<quick_xml_deserialize::BlockOutputVariablesVariableElementTypeDeserializer>;
    }
    impl WithSerializer for BlockOutputVariablesVariableElementType {
        type Serializer<'x> =
            quick_xml_serialize::BlockOutputVariablesVariableElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: BlockOutputVariablesVariableElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: BlockOutputVariablesVariableElementTypeSerializerState :: Init__) , name : name . unwrap_or ("BlockOutputVariablesVariable") , is_root , })
        }
    }
    #[derive(Debug)]
    pub struct TransitionConditionInlineElementType {
        pub worksheet_name: Option<::std::string::String>,
        pub global_id: Option<::std::string::String>,
        pub name: ::std::string::String,
        pub content: Vec<TransitionConditionInlineElementTypeContent>,
    }
    #[derive(Debug)]
    pub enum TransitionConditionInlineElementTypeContent {
        Il(FormattedTextType),
        St(FormattedTextType),
        Fbd(BodyFbdElementType),
        Ld(BodyLdElementType),
        Sfc(BodySfcElementType),
        AddData(AddDataType),
        #[doc = "Additional userspecific information to the element"]
        Documentation(FormattedTextType),
    }
    impl WithDeserializer for TransitionConditionInlineElementType {
        type Deserializer =
            Box<quick_xml_deserialize::TransitionConditionInlineElementTypeDeserializer>;
    }
    impl WithDeserializer for TransitionConditionInlineElementTypeContent {
        type Deserializer =
            Box<quick_xml_deserialize::TransitionConditionInlineElementTypeContentDeserializer>;
    }
    impl WithSerializer for TransitionConditionInlineElementType {
        type Serializer<'x> =
            quick_xml_serialize::TransitionConditionInlineElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: TransitionConditionInlineElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: TransitionConditionInlineElementTypeSerializerState :: Init__) , name : name . unwrap_or ("TransitionConditionInline") , is_root , })
        }
    }
    impl WithSerializer for TransitionConditionInlineElementTypeContent {
        type Serializer<'x> =
            quick_xml_serialize::TransitionConditionInlineElementTypeContentSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            let _name = name;
            let _is_root = is_root;
            Ok (quick_xml_serialize :: TransitionConditionInlineElementTypeContentSerializer { value : self , state : Box :: new (quick_xml_serialize :: TransitionConditionInlineElementTypeContentSerializerState :: Init__) , })
        }
    }
    #[derive(Debug)]
    pub struct ProjectTypesPousPouInterfaceElementType {
        pub content: Vec<ProjectTypesPousPouInterfaceElementTypeContent>,
    }
    #[derive(Debug)]
    pub enum ProjectTypesPousPouInterfaceElementTypeContent {
        ReturnType(DataType),
        LocalVars(ProjectTypesPousPouInterfaceExternalVarsElementType),
        TempVars(ProjectTypesPousPouInterfaceExternalVarsElementType),
        InputVars(ProjectTypesPousPouInterfaceExternalVarsElementType),
        OutputVars(ProjectTypesPousPouInterfaceExternalVarsElementType),
        InOutVars(ProjectTypesPousPouInterfaceExternalVarsElementType),
        ExternalVars(ProjectTypesPousPouInterfaceExternalVarsElementType),
        GlobalVars(ProjectTypesPousPouInterfaceExternalVarsElementType),
        AccessVars(VarListType),
        AddData(AddDataType),
        #[doc = "Additional"]
        #[doc = "userspecific information"]
        #[doc = "to the element"]
        Documentation(FormattedTextType),
    }
    impl WithDeserializer for ProjectTypesPousPouInterfaceElementType {
        type Deserializer =
            Box<quick_xml_deserialize::ProjectTypesPousPouInterfaceElementTypeDeserializer>;
    }
    impl WithDeserializer for ProjectTypesPousPouInterfaceElementTypeContent {
        type Deserializer =
            Box<quick_xml_deserialize::ProjectTypesPousPouInterfaceElementTypeContentDeserializer>;
    }
    impl WithSerializer for ProjectTypesPousPouInterfaceElementType {
        type Serializer<'x> =
            quick_xml_serialize::ProjectTypesPousPouInterfaceElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: ProjectTypesPousPouInterfaceElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: ProjectTypesPousPouInterfaceElementTypeSerializerState :: Init__) , name : name . unwrap_or ("ProjectTypesPousPouInterface") , is_root , })
        }
    }
    impl WithSerializer for ProjectTypesPousPouInterfaceElementTypeContent {
        type Serializer<'x> =
            quick_xml_serialize::ProjectTypesPousPouInterfaceElementTypeContentSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            let _name = name;
            let _is_root = is_root;
            Ok (quick_xml_serialize :: ProjectTypesPousPouInterfaceElementTypeContentSerializer { value : self , state : Box :: new (quick_xml_serialize :: ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: Init__) , })
        }
    }
    #[derive(Debug)]
    pub struct ProjectTypesPousPouActionsElementType {
        pub action: Vec<ProjectTypesPousPouActionsActionElementType>,
    }
    impl WithDeserializer for ProjectTypesPousPouActionsElementType {
        type Deserializer =
            Box<quick_xml_deserialize::ProjectTypesPousPouActionsElementTypeDeserializer>;
    }
    impl WithSerializer for ProjectTypesPousPouActionsElementType {
        type Serializer<'x> =
            quick_xml_serialize::ProjectTypesPousPouActionsElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: ProjectTypesPousPouActionsElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: ProjectTypesPousPouActionsElementTypeSerializerState :: Init__) , name : name . unwrap_or ("ProjectTypesPousPouActions") , is_root , })
        }
    }
    #[derive(Debug)]
    pub struct ProjectTypesPousPouTransitionsElementType {
        pub transition: Vec<ProjectTypesPousPouActionsActionElementType>,
    }
    impl WithDeserializer for ProjectTypesPousPouTransitionsElementType {
        type Deserializer =
            Box<quick_xml_deserialize::ProjectTypesPousPouTransitionsElementTypeDeserializer>;
    }
    impl WithSerializer for ProjectTypesPousPouTransitionsElementType {
        type Serializer<'x> =
            quick_xml_serialize::ProjectTypesPousPouTransitionsElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: ProjectTypesPousPouTransitionsElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: ProjectTypesPousPouTransitionsElementTypeSerializerState :: Init__) , name : name . unwrap_or ("ProjectTypesPousPouTransitions") , is_root , })
        }
    }
    #[doc = "Represents a"]
    #[doc = "group of programs and tasks and"]
    #[doc = "global variables"]
    #[derive(Debug)]
    pub struct ProjectInstancesConfigurationsConfigurationResourceElementType {
        pub name: ::std::string::String,
        pub global_id: Option<::std::string::String>,
        pub task: Vec<ProjectInstancesConfigurationsConfigurationResourceTaskElementType>,
        pub global_vars: Vec<VarListType>,
        pub pou_instance: Vec<PouInstanceType>,
        pub add_data: Option<AddDataType>,
        #[doc = "Additional"]
        #[doc = "userspecific information"]
        #[doc = "to the element"]
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for ProjectInstancesConfigurationsConfigurationResourceElementType {
        type Deserializer = Box < quick_xml_deserialize :: ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializer > ;
    }
    impl WithSerializer for ProjectInstancesConfigurationsConfigurationResourceElementType {
        type Serializer < 'x > = quick_xml_serialize :: ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializer < 'x > ;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: Init__) , name : name . unwrap_or ("ProjectInstancesConfigurationsConfigurationResource") , is_root , })
        }
    }
    #[derive(Debug)]
    pub struct ProjectTypesPousPouInterfaceExternalVarsElementType {
        pub name: Option<::std::string::String>,
        pub constant: ::core::primitive::bool,
        pub retain: ::core::primitive::bool,
        pub nonretain: ::core::primitive::bool,
        pub persistent: ::core::primitive::bool,
        pub nonpersistent: ::core::primitive::bool,
        pub variable: Vec<VarListPlainVariableElementType>,
        pub add_data: Option<AddDataType>,
        pub documentation: Option<FormattedTextType>,
    }
    impl ProjectTypesPousPouInterfaceExternalVarsElementType {
        #[must_use]
        pub fn default_constant() -> ::core::primitive::bool {
            false
        }
        #[must_use]
        pub fn default_retain() -> ::core::primitive::bool {
            false
        }
        #[must_use]
        pub fn default_nonretain() -> ::core::primitive::bool {
            false
        }
        #[must_use]
        pub fn default_persistent() -> ::core::primitive::bool {
            false
        }
        #[must_use]
        pub fn default_nonpersistent() -> ::core::primitive::bool {
            false
        }
    }
    impl WithDeserializer for ProjectTypesPousPouInterfaceExternalVarsElementType {
        type Deserializer = Box<
            quick_xml_deserialize::ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializer,
        >;
    }
    impl WithSerializer for ProjectTypesPousPouInterfaceExternalVarsElementType {
        type Serializer<'x> =
            quick_xml_serialize::ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializerState :: Init__) , name : name . unwrap_or ("ProjectTypesPousPouInterfaceExternalVars") , is_root , })
        }
    }
    #[derive(Debug)]
    pub struct ProjectTypesPousPouActionsActionElementType {
        pub name: ::std::string::String,
        pub global_id: Option<::std::string::String>,
        pub body: BodyType,
        pub add_data: Option<AddDataType>,
        #[doc = "Additional"]
        #[doc = "userspecific"]
        #[doc = "information"]
        #[doc = "to the"]
        #[doc = "element"]
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for ProjectTypesPousPouActionsActionElementType {
        type Deserializer =
            Box<quick_xml_deserialize::ProjectTypesPousPouActionsActionElementTypeDeserializer>;
    }
    impl WithSerializer for ProjectTypesPousPouActionsActionElementType {
        type Serializer<'x> =
            quick_xml_serialize::ProjectTypesPousPouActionsActionElementTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: ProjectTypesPousPouActionsActionElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: ProjectTypesPousPouActionsActionElementTypeSerializerState :: Init__) , name : name . unwrap_or ("ProjectTypesPousPouActionsAction") , is_root , })
        }
    }
    #[doc = "Represents"]
    #[doc = "a periodic or"]
    #[doc = "triggered task"]
    #[derive(Debug)]
    pub struct ProjectInstancesConfigurationsConfigurationResourceTaskElementType {
        pub name: ::std::string::String,
        pub single: Option<::std::string::String>,
        #[doc = "Vendor"]
        #[doc = "specific: Either"]
        #[doc = "a constant"]
        #[doc = "duration as"]
        #[doc = "defined in the"]
        #[doc = "IEC or variable"]
        #[doc = "name."]
        pub interval: Option<::std::string::String>,
        pub priority: BigInt,
        pub global_id: Option<::std::string::String>,
        pub pou_instance: Vec<PouInstanceType>,
        pub add_data: Option<AddDataType>,
        #[doc = "Additional"]
        #[doc = "userspecific"]
        #[doc = "information"]
        #[doc = "to the"]
        #[doc = "element"]
        pub documentation: Option<FormattedTextType>,
    }
    impl WithDeserializer for ProjectInstancesConfigurationsConfigurationResourceTaskElementType {
        type Deserializer = Box < quick_xml_deserialize :: ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializer > ;
    }
    impl WithSerializer for ProjectInstancesConfigurationsConfigurationResourceTaskElementType {
        type Serializer < 'x > = quick_xml_serialize :: ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializer < 'x > ;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok (quick_xml_serialize :: ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializerState :: Init__) , name : name . unwrap_or ("ProjectInstancesConfigurationsConfigurationResourceTask") , is_root , })
        }
    }
    pub mod quick_xml_deserialize {
        use core::mem::replace;
        use num::BigInt;
        use xsd_parser::{
            quick_xml::{
                filter_xmlns_attributes, BytesStart, DeserializeReader, Deserializer,
                DeserializerArtifact, DeserializerEvent, DeserializerOutput, DeserializerResult,
                ElementHandlerOutput, Error, ErrorKind, Event, RawByteStr, WithDeserializer,
            },
            xml::AnyElement,
        };
        #[derive(Debug)]
        pub struct AddDataTypeDeserializer {
            data: Vec<super::AddDataDataElementType>,
            state: Box<AddDataTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum AddDataTypeDeserializerState {
            Init__,
            Data(Option<<super::AddDataDataElementType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl AddDataTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    data: Vec::new(),
                    state: Box::new(AddDataTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: AddDataTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use AddDataTypeDeserializerState as S;
                match state {
                    S::Data(Some(deserializer)) => self.store_data(deserializer.finish(reader)?)?,
                    _ => (),
                }
                Ok(())
            }
            fn store_data(&mut self, value: super::AddDataDataElementType) -> Result<(), Error> {
                self.data.push(value);
                Ok(())
            }
            fn handle_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataDataElementType>,
                fallback: &mut Option<AddDataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(AddDataTypeDeserializerState::Data(None));
                    *self.state = AddDataTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_data(data)?;
                        *self.state = AddDataTypeDeserializerState::Data(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(AddDataTypeDeserializerState::Data(Some(
                                    deserializer,
                                )));
                                *self.state = AddDataTypeDeserializerState::Data(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    AddDataTypeDeserializerState::Data(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::AddDataType> for Box<AddDataTypeDeserializer> {
            fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, super::AddDataType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    AddDataTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::AddDataType>
            where
                R: DeserializeReader,
            {
                use AddDataTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Data(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = AddDataTypeDeserializerState::Data(None);
                            event
                        }
                        (S::Data(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"data",
                                true,
                            )?;
                            match self.handle_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::AddDataType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(&mut *self.state, AddDataTypeDeserializerState::Unknown__);
                self.finish_state(reader, state)?;
                Ok(super::AddDataType { data: self.data })
            }
        }
        #[derive(Debug)]
        pub struct AddDataInfoTypeDeserializer {
            info: Vec<super::AddDataInfoInfoElementType>,
            state: Box<AddDataInfoTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum AddDataInfoTypeDeserializerState {
            Init__,
            Info(Option<<super::AddDataInfoInfoElementType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl AddDataInfoTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    info: Vec::new(),
                    state: Box::new(AddDataInfoTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: AddDataInfoTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use AddDataInfoTypeDeserializerState as S;
                match state {
                    S::Info(Some(deserializer)) => self.store_info(deserializer.finish(reader)?)?,
                    _ => (),
                }
                Ok(())
            }
            fn store_info(
                &mut self,
                value: super::AddDataInfoInfoElementType,
            ) -> Result<(), Error> {
                self.info.push(value);
                Ok(())
            }
            fn handle_info<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataInfoInfoElementType>,
                fallback: &mut Option<AddDataInfoTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(AddDataInfoTypeDeserializerState::Info(None));
                    *self.state = AddDataInfoTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_info(data)?;
                        *self.state = AddDataInfoTypeDeserializerState::Info(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(AddDataInfoTypeDeserializerState::Info(
                                    Some(deserializer),
                                ));
                                *self.state = AddDataInfoTypeDeserializerState::Info(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    AddDataInfoTypeDeserializerState::Info(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::AddDataInfoType> for Box<AddDataInfoTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::AddDataInfoType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    AddDataInfoTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::AddDataInfoType>
            where
                R: DeserializeReader,
            {
                use AddDataInfoTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Info(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_info(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = AddDataInfoTypeDeserializerState::Info(None);
                            event
                        }
                        (S::Info(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"info",
                                true,
                            )?;
                            match self.handle_info(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::AddDataInfoType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    AddDataInfoTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::AddDataInfoType { info: self.info })
            }
        }
        #[derive(Debug)]
        pub struct BodyTypeDeserializer {
            worksheet_name: Option<::std::string::String>,
            global_id: Option<::std::string::String>,
            content: Vec<super::BodyTypeContent>,
            state: Box<BodyTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum BodyTypeDeserializerState {
            Init__,
            Next__,
            Content__(<super::BodyTypeContent as WithDeserializer>::Deserializer),
            Unknown__,
        }
        impl BodyTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut worksheet_name: Option<::std::string::String> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"WorksheetName")
                    ) {
                        reader.read_attrib(&mut worksheet_name, b"WorksheetName", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    worksheet_name: worksheet_name,
                    global_id: global_id,
                    content: Vec::new(),
                    state: Box::new(BodyTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: BodyTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                if let BodyTypeDeserializerState::Content__(deserializer) = state {
                    self.store_content(deserializer.finish(reader)?)?;
                }
                Ok(())
            }
            fn store_content(&mut self, value: super::BodyTypeContent) -> Result<(), Error> {
                self.content.push(value);
                Ok(())
            }
            fn handle_content<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::BodyTypeContent>,
                fallback: &mut Option<BodyTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = fallback.take().unwrap_or(BodyTypeDeserializerState::Next__);
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_content(data)?;
                        *self.state = BodyTypeDeserializerState::Next__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let can_have_more = self.content.len().saturating_add(1) < 3usize;
                        let ret = if can_have_more {
                            ElementHandlerOutput::from_event(event, allow_any)
                        } else {
                            ElementHandlerOutput::from_event_end(event, allow_any)
                        };
                        match (can_have_more, &ret) {
                            (true, ElementHandlerOutput::Continue { .. }) => {
                                fallback.get_or_insert(BodyTypeDeserializerState::Content__(
                                    deserializer,
                                ));
                                *self.state = BodyTypeDeserializerState::Next__;
                            }
                            (false, _) | (_, ElementHandlerOutput::Break { .. }) => {
                                *self.state = BodyTypeDeserializerState::Content__(deserializer);
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::BodyType> for Box<BodyTypeDeserializer> {
            fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, super::BodyType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    BodyTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BodyType>
            where
                R: DeserializeReader,
            {
                use BodyTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Content__(deserializer), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (_, Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (state @ (S::Init__ | S::Next__), event) => {
                            fallback.get_or_insert(state);
                            let output =
                                <super::BodyTypeContent as WithDeserializer>::Deserializer::init(
                                    reader, event,
                                )?;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = DeserializerArtifact::Deserializer(self);
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::BodyType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(&mut *self.state, BodyTypeDeserializerState::Unknown__);
                self.finish_state(reader, state)?;
                Ok(super::BodyType {
                    worksheet_name: self.worksheet_name,
                    global_id: self.global_id,
                    content: self.content,
                })
            }
        }
        #[derive(Debug)]
        pub struct BodyTypeContentDeserializer {
            state: Box<BodyTypeContentDeserializerState>,
        }
        #[derive(Debug)]
        pub enum BodyTypeContentDeserializerState {
            Init__,
            Il(
                Option<super::FormattedTextType>,
                Option<<super::FormattedTextType as WithDeserializer>::Deserializer>,
            ),
            St(
                Option<super::FormattedTextType>,
                Option<<super::FormattedTextType as WithDeserializer>::Deserializer>,
            ),
            Fbd(
                Option<super::BodyFbdElementType>,
                Option<<super::BodyFbdElementType as WithDeserializer>::Deserializer>,
            ),
            Ld(
                Option<super::BodyLdElementType>,
                Option<<super::BodyLdElementType as WithDeserializer>::Deserializer>,
            ),
            Sfc(
                Option<super::BodySfcElementType>,
                Option<<super::BodySfcElementType as WithDeserializer>::Deserializer>,
            ),
            AddData(
                Option<super::AddDataType>,
                Option<<super::AddDataType as WithDeserializer>::Deserializer>,
            ),
            Documentation(
                Option<super::FormattedTextType>,
                Option<<super::FormattedTextType as WithDeserializer>::Deserializer>,
            ),
            Done__(super::BodyTypeContent),
            Unknown__,
        }
        impl BodyTypeContentDeserializer {
            fn find_suitable<'de, R>(
                &mut self,
                reader: &R,
                event: Event<'de>,
                fallback: &mut Option<BodyTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                if let Event::Start(x) | Event::Empty(x) = &event {
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"IL")
                    ) {
                        let output =
                            <super::FormattedTextType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_il(reader, Default::default(), output, &mut *fallback);
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"ST")
                    ) {
                        let output =
                            <super::FormattedTextType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_st(reader, Default::default(), output, &mut *fallback);
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"FBD")
                    ) {
                        let output =
                            <super::BodyFbdElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_fbd(reader, Default::default(), output, &mut *fallback);
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"LD")
                    ) {
                        let output =
                            <super::BodyLdElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_ld(reader, Default::default(), output, &mut *fallback);
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"SFC")
                    ) {
                        let output =
                            <super::BodySfcElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_sfc(reader, Default::default(), output, &mut *fallback);
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"addData")
                    ) {
                        let output = <super::AddDataType as WithDeserializer>::Deserializer::init(
                            reader, event,
                        )?;
                        return self.handle_add_data(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"documentation")
                    ) {
                        let output =
                            <super::FormattedTextType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_documentation(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                }
                *self.state = fallback
                    .take()
                    .unwrap_or(BodyTypeContentDeserializerState::Init__);
                Ok(ElementHandlerOutput::return_to_parent(event, false))
            }
            fn finish_state<R>(
                reader: &R,
                state: BodyTypeContentDeserializerState,
            ) -> Result<super::BodyTypeContent, Error>
            where
                R: DeserializeReader,
            {
                use BodyTypeContentDeserializerState as S;
                match state {
                    S::Init__ => Err(ErrorKind::MissingContent.into()),
                    S::Il(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyTypeContentDeserializer::store_il(&mut values, value)?;
                        }
                        Ok(super::BodyTypeContent::Il(
                            values.ok_or_else(|| ErrorKind::MissingElement("IL".into()))?,
                        ))
                    }
                    S::St(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyTypeContentDeserializer::store_st(&mut values, value)?;
                        }
                        Ok(super::BodyTypeContent::St(
                            values.ok_or_else(|| ErrorKind::MissingElement("ST".into()))?,
                        ))
                    }
                    S::Fbd(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyTypeContentDeserializer::store_fbd(&mut values, value)?;
                        }
                        Ok(super::BodyTypeContent::Fbd(
                            values.ok_or_else(|| ErrorKind::MissingElement("FBD".into()))?,
                        ))
                    }
                    S::Ld(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyTypeContentDeserializer::store_ld(&mut values, value)?;
                        }
                        Ok(super::BodyTypeContent::Ld(
                            values.ok_or_else(|| ErrorKind::MissingElement("LD".into()))?,
                        ))
                    }
                    S::Sfc(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyTypeContentDeserializer::store_sfc(&mut values, value)?;
                        }
                        Ok(super::BodyTypeContent::Sfc(
                            values.ok_or_else(|| ErrorKind::MissingElement("SFC".into()))?,
                        ))
                    }
                    S::AddData(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyTypeContentDeserializer::store_add_data(&mut values, value)?;
                        }
                        Ok(super::BodyTypeContent::AddData(values.ok_or_else(
                            || ErrorKind::MissingElement("addData".into()),
                        )?))
                    }
                    S::Documentation(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyTypeContentDeserializer::store_documentation(&mut values, value)?;
                        }
                        Ok(super::BodyTypeContent::Documentation(values.ok_or_else(
                            || ErrorKind::MissingElement("documentation".into()),
                        )?))
                    }
                    S::Done__(data) => Ok(data),
                    S::Unknown__ => unreachable!(),
                }
            }
            fn store_il(
                values: &mut Option<super::FormattedTextType>,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"IL")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_st(
                values: &mut Option<super::FormattedTextType>,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"ST")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_fbd(
                values: &mut Option<super::BodyFbdElementType>,
                value: super::BodyFbdElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"FBD")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_ld(
                values: &mut Option<super::BodyLdElementType>,
                value: super::BodyLdElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"LD")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_sfc(
                values: &mut Option<super::BodySfcElementType>,
                value: super::BodySfcElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"SFC")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_add_data(
                values: &mut Option<super::AddDataType>,
                value: super::AddDataType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_documentation(
                values: &mut Option<super::FormattedTextType>,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn handle_il<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::FormattedTextType>,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<BodyTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyTypeContentDeserializerState::Il(values, None),
                        Some(BodyTypeContentDeserializerState::Il(_, Some(deserializer))) => {
                            BodyTypeContentDeserializerState::Il(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyTypeContentDeserializerState::Il(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        BodyTypeContentDeserializer::store_il(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyTypeContentDeserializer::store_il(&mut values, data)?;
                        let data = BodyTypeContentDeserializer::finish_state(
                            reader,
                            BodyTypeContentDeserializerState::Il(values, None),
                        )?;
                        *self.state = BodyTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            BodyTypeContentDeserializerState::Il(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_st<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::FormattedTextType>,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<BodyTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyTypeContentDeserializerState::St(values, None),
                        Some(BodyTypeContentDeserializerState::St(_, Some(deserializer))) => {
                            BodyTypeContentDeserializerState::St(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyTypeContentDeserializerState::St(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        BodyTypeContentDeserializer::store_st(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyTypeContentDeserializer::store_st(&mut values, data)?;
                        let data = BodyTypeContentDeserializer::finish_state(
                            reader,
                            BodyTypeContentDeserializerState::St(values, None),
                        )?;
                        *self.state = BodyTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            BodyTypeContentDeserializerState::St(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_fbd<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::BodyFbdElementType>,
                output: DeserializerOutput<'de, super::BodyFbdElementType>,
                fallback: &mut Option<BodyTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyTypeContentDeserializerState::Fbd(values, None),
                        Some(BodyTypeContentDeserializerState::Fbd(_, Some(deserializer))) => {
                            BodyTypeContentDeserializerState::Fbd(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyTypeContentDeserializerState::Fbd(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        BodyTypeContentDeserializer::store_fbd(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyTypeContentDeserializer::store_fbd(&mut values, data)?;
                        let data = BodyTypeContentDeserializer::finish_state(
                            reader,
                            BodyTypeContentDeserializerState::Fbd(values, None),
                        )?;
                        *self.state = BodyTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            BodyTypeContentDeserializerState::Fbd(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_ld<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::BodyLdElementType>,
                output: DeserializerOutput<'de, super::BodyLdElementType>,
                fallback: &mut Option<BodyTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyTypeContentDeserializerState::Ld(values, None),
                        Some(BodyTypeContentDeserializerState::Ld(_, Some(deserializer))) => {
                            BodyTypeContentDeserializerState::Ld(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyTypeContentDeserializerState::Ld(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        BodyTypeContentDeserializer::store_ld(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyTypeContentDeserializer::store_ld(&mut values, data)?;
                        let data = BodyTypeContentDeserializer::finish_state(
                            reader,
                            BodyTypeContentDeserializerState::Ld(values, None),
                        )?;
                        *self.state = BodyTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            BodyTypeContentDeserializerState::Ld(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_sfc<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::BodySfcElementType>,
                output: DeserializerOutput<'de, super::BodySfcElementType>,
                fallback: &mut Option<BodyTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyTypeContentDeserializerState::Sfc(values, None),
                        Some(BodyTypeContentDeserializerState::Sfc(_, Some(deserializer))) => {
                            BodyTypeContentDeserializerState::Sfc(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyTypeContentDeserializerState::Sfc(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        BodyTypeContentDeserializer::store_sfc(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyTypeContentDeserializer::store_sfc(&mut values, data)?;
                        let data = BodyTypeContentDeserializer::finish_state(
                            reader,
                            BodyTypeContentDeserializerState::Sfc(values, None),
                        )?;
                        *self.state = BodyTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            BodyTypeContentDeserializerState::Sfc(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::AddDataType>,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<BodyTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyTypeContentDeserializerState::AddData(values, None),
                        Some(BodyTypeContentDeserializerState::AddData(_, Some(deserializer))) => {
                            BodyTypeContentDeserializerState::AddData(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyTypeContentDeserializerState::AddData(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        BodyTypeContentDeserializer::store_add_data(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyTypeContentDeserializer::store_add_data(&mut values, data)?;
                        let data = BodyTypeContentDeserializer::finish_state(
                            reader,
                            BodyTypeContentDeserializerState::AddData(values, None),
                        )?;
                        *self.state = BodyTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            BodyTypeContentDeserializerState::AddData(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::FormattedTextType>,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<BodyTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyTypeContentDeserializerState::Documentation(values, None),
                        Some(BodyTypeContentDeserializerState::Documentation(
                            _,
                            Some(deserializer),
                        )) => BodyTypeContentDeserializerState::Documentation(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyTypeContentDeserializerState::Documentation(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyTypeContentDeserializer::store_documentation(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyTypeContentDeserializer::store_documentation(&mut values, data)?;
                        let data = BodyTypeContentDeserializer::finish_state(
                            reader,
                            BodyTypeContentDeserializerState::Documentation(values, None),
                        )?;
                        *self.state = BodyTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyTypeContentDeserializerState::Documentation(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::BodyTypeContent> for Box<BodyTypeContentDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BodyTypeContent>
            where
                R: DeserializeReader,
            {
                let deserializer = Box::new(BodyTypeContentDeserializer {
                    state: Box::new(BodyTypeContentDeserializerState::Init__),
                });
                let mut output = deserializer.next(reader, event)?;
                output.artifact = match output.artifact {
                    DeserializerArtifact::Deserializer(x)
                        if matches!(&*x.state, BodyTypeContentDeserializerState::Init__) =>
                    {
                        DeserializerArtifact::None
                    }
                    artifact => artifact,
                };
                Ok(output)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BodyTypeContent>
            where
                R: DeserializeReader,
            {
                use BodyTypeContentDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Il(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_il(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::St(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_st(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Fbd(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_fbd(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Ld(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_ld(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Sfc(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_sfc(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AddData(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Documentation(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (state, event @ Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(
                                    BodyTypeContentDeserializer::finish_state(reader, state)?,
                                ),
                                event: DeserializerEvent::Continue(event),
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            match self.find_suitable(reader, event, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Il(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"IL",
                                true,
                            )?;
                            match self.handle_il(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::St(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"ST",
                                true,
                            )?;
                            match self.handle_st(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Fbd(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"FBD",
                                false,
                            )?;
                            match self.handle_fbd(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Ld(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"LD",
                                false,
                            )?;
                            match self.handle_ld(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Sfc(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"SFC",
                                false,
                            )?;
                            match self.handle_sfc(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AddData(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Documentation(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (s @ S::Done__(_), event) => {
                            *self.state = s;
                            break (DeserializerEvent::Continue(event), false);
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = if matches!(&*self.state, S::Done__(_)) {
                    DeserializerArtifact::Data(self.finish(reader)?)
                } else {
                    DeserializerArtifact::Deserializer(self)
                };
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(self, reader: &R) -> Result<super::BodyTypeContent, Error>
            where
                R: DeserializeReader,
            {
                BodyTypeContentDeserializer::finish_state(reader, *self.state)
            }
        }
        #[derive(Debug)]
        pub struct ConnectionTypeDeserializer {
            global_id: Option<::std::string::String>,
            ref_local_id: ::core::primitive::u64,
            formal_parameter: Option<::std::string::String>,
            position: Vec<super::PositionType>,
            add_data: Option<super::AddDataType>,
            state: Box<ConnectionTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ConnectionTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl ConnectionTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut global_id: Option<::std::string::String> = None;
                let mut ref_local_id: Option<::core::primitive::u64> = None;
                let mut formal_parameter: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"refLocalId")
                    ) {
                        reader.read_attrib(&mut ref_local_id, b"refLocalId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"formalParameter")
                    ) {
                        reader.read_attrib(
                            &mut formal_parameter,
                            b"formalParameter",
                            &attrib.value,
                        )?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    global_id: global_id,
                    ref_local_id: ref_local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("refLocalId".into()))
                    })?,
                    formal_parameter: formal_parameter,
                    position: Vec::new(),
                    add_data: None,
                    state: Box::new(ConnectionTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ConnectionTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ConnectionTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                self.position.push(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<ConnectionTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(ConnectionTypeDeserializerState::Position(None));
                    *self.state = ConnectionTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state = ConnectionTypeDeserializerState::Position(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(ConnectionTypeDeserializerState::Position(
                                    Some(deserializer),
                                ));
                                *self.state = ConnectionTypeDeserializerState::Position(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ConnectionTypeDeserializerState::Position(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<ConnectionTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(ConnectionTypeDeserializerState::AddData(None));
                    *self.state = ConnectionTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = ConnectionTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(ConnectionTypeDeserializerState::AddData(
                                    Some(deserializer),
                                ));
                                *self.state = ConnectionTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ConnectionTypeDeserializerState::AddData(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ConnectionType> for Box<ConnectionTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ConnectionType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ConnectionTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ConnectionType>
            where
                R: DeserializeReader,
            {
                use ConnectionTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = ConnectionTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::ConnectionType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(&mut *self.state, ConnectionTypeDeserializerState::Unknown__);
                self.finish_state(reader, state)?;
                Ok(super::ConnectionType {
                    global_id: self.global_id,
                    ref_local_id: self.ref_local_id,
                    formal_parameter: self.formal_parameter,
                    position: self.position,
                    add_data: self.add_data,
                })
            }
        }
        #[derive(Debug)]
        pub struct ConnectionPointInTypeDeserializer {
            global_id: Option<::std::string::String>,
            content: Vec<super::ConnectionPointInTypeContent>,
            state: Box<ConnectionPointInTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ConnectionPointInTypeDeserializerState {
            Init__,
            Next__,
            Content__(<super::ConnectionPointInTypeContent as WithDeserializer>::Deserializer),
            Unknown__,
        }
        impl ConnectionPointInTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    global_id: global_id,
                    content: Vec::new(),
                    state: Box::new(ConnectionPointInTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ConnectionPointInTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                if let ConnectionPointInTypeDeserializerState::Content__(deserializer) = state {
                    self.store_content(deserializer.finish(reader)?)?;
                }
                Ok(())
            }
            fn store_content(
                &mut self,
                value: super::ConnectionPointInTypeContent,
            ) -> Result<(), Error> {
                self.content.push(value);
                Ok(())
            }
            fn handle_content<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInTypeContent>,
                fallback: &mut Option<ConnectionPointInTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = fallback
                        .take()
                        .unwrap_or(ConnectionPointInTypeDeserializerState::Next__);
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_content(data)?;
                        *self.state = ConnectionPointInTypeDeserializerState::Next__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ConnectionPointInTypeDeserializerState::Content__(deserializer);
                            }
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ConnectionPointInTypeDeserializerState::Content__(deserializer),
                                );
                                *self.state = ConnectionPointInTypeDeserializerState::Next__;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ConnectionPointInType>
            for Box<ConnectionPointInTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ConnectionPointInType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ConnectionPointInTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ConnectionPointInType>
            where
                R: DeserializeReader,
            {
                use ConnectionPointInTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Content__(deserializer), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (_, Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (state @ (S::Init__ | S::Next__), event) => {
                            fallback.get_or_insert(state);
                            let output = < super :: ConnectionPointInTypeContent as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = DeserializerArtifact::Deserializer(self);
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::ConnectionPointInType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ConnectionPointInTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ConnectionPointInType {
                    global_id: self.global_id,
                    content: self.content,
                })
            }
        }
        #[derive(Debug)]
        pub struct ConnectionPointInTypeContentDeserializer {
            state: Box<ConnectionPointInTypeContentDeserializerState>,
        }
        #[derive(Debug)]
        pub enum ConnectionPointInTypeContentDeserializerState {
            Init__,
            RelPosition(
                Option<super::PositionType>,
                Option<<super::PositionType as WithDeserializer>::Deserializer>,
            ),
            Connection(
                Option<super::ConnectionType>,
                Option<<super::ConnectionType as WithDeserializer>::Deserializer>,
            ),
            Expression(
                Option<::std::string::String>,
                Option<<::std::string::String as WithDeserializer>::Deserializer>,
            ),
            AddData(
                Option<super::AddDataType>,
                Option<<super::AddDataType as WithDeserializer>::Deserializer>,
            ),
            Done__(super::ConnectionPointInTypeContent),
            Unknown__,
        }
        impl ConnectionPointInTypeContentDeserializer {
            fn find_suitable<'de, R>(
                &mut self,
                reader: &R,
                event: Event<'de>,
                fallback: &mut Option<ConnectionPointInTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                if let Event::Start(x) | Event::Empty(x) = &event {
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"relPosition")
                    ) {
                        let output = <super::PositionType as WithDeserializer>::Deserializer::init(
                            reader, event,
                        )?;
                        return self.handle_rel_position(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"connection")
                    ) {
                        let output =
                            <super::ConnectionType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_connection(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"expression")
                    ) {
                        let output =
                            <::std::string::String as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_expression(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"addData")
                    ) {
                        let output = <super::AddDataType as WithDeserializer>::Deserializer::init(
                            reader, event,
                        )?;
                        return self.handle_add_data(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                }
                *self.state = fallback
                    .take()
                    .unwrap_or(ConnectionPointInTypeContentDeserializerState::Init__);
                Ok(ElementHandlerOutput::return_to_parent(event, false))
            }
            fn finish_state<R>(
                reader: &R,
                state: ConnectionPointInTypeContentDeserializerState,
            ) -> Result<super::ConnectionPointInTypeContent, Error>
            where
                R: DeserializeReader,
            {
                use ConnectionPointInTypeContentDeserializerState as S;
                match state {
                    S::Init__ => Err(ErrorKind::MissingContent.into()),
                    S::RelPosition(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ConnectionPointInTypeContentDeserializer::store_rel_position(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::ConnectionPointInTypeContent::RelPosition(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("relPosition".into()))?,
                        ))
                    }
                    S::Connection(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ConnectionPointInTypeContentDeserializer::store_connection(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::ConnectionPointInTypeContent::Connection(
                            values.ok_or_else(|| ErrorKind::MissingElement("connection".into()))?,
                        ))
                    }
                    S::Expression(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ConnectionPointInTypeContentDeserializer::store_expression(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::ConnectionPointInTypeContent::Expression(
                            values.ok_or_else(|| ErrorKind::MissingElement("expression".into()))?,
                        ))
                    }
                    S::AddData(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ConnectionPointInTypeContentDeserializer::store_add_data(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::ConnectionPointInTypeContent::AddData(
                            values.ok_or_else(|| ErrorKind::MissingElement("addData".into()))?,
                        ))
                    }
                    S::Done__(data) => Ok(data),
                    S::Unknown__ => unreachable!(),
                }
            }
            fn store_rel_position(
                values: &mut Option<super::PositionType>,
                value: super::PositionType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"relPosition",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_connection(
                values: &mut Option<super::ConnectionType>,
                value: super::ConnectionType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connection",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_expression(
                values: &mut Option<::std::string::String>,
                value: ::std::string::String,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"expression",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_add_data(
                values: &mut Option<super::AddDataType>,
                value: super::AddDataType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn handle_rel_position<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::PositionType>,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<ConnectionPointInTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = ConnectionPointInTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            ConnectionPointInTypeContentDeserializerState::RelPosition(values, None)
                        }
                        Some(ConnectionPointInTypeContentDeserializerState::RelPosition(
                            _,
                            Some(deserializer),
                        )) => ConnectionPointInTypeContentDeserializerState::RelPosition(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(ConnectionPointInTypeContentDeserializerState::RelPosition(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        ConnectionPointInTypeContentDeserializer::store_rel_position(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ConnectionPointInTypeContentDeserializer::store_rel_position(
                            &mut values,
                            data,
                        )?;
                        let data = ConnectionPointInTypeContentDeserializer::finish_state(
                            reader,
                            ConnectionPointInTypeContentDeserializerState::RelPosition(
                                values, None,
                            ),
                        )?;
                        *self.state = ConnectionPointInTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = ConnectionPointInTypeContentDeserializerState::RelPosition(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_connection<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ConnectionType>,
                output: DeserializerOutput<'de, super::ConnectionType>,
                fallback: &mut Option<ConnectionPointInTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = ConnectionPointInTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            ConnectionPointInTypeContentDeserializerState::Connection(values, None)
                        }
                        Some(ConnectionPointInTypeContentDeserializerState::Connection(
                            _,
                            Some(deserializer),
                        )) => ConnectionPointInTypeContentDeserializerState::Connection(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(ConnectionPointInTypeContentDeserializerState::Connection(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        ConnectionPointInTypeContentDeserializer::store_connection(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ConnectionPointInTypeContentDeserializer::store_connection(
                            &mut values,
                            data,
                        )?;
                        let data = ConnectionPointInTypeContentDeserializer::finish_state(
                            reader,
                            ConnectionPointInTypeContentDeserializerState::Connection(values, None),
                        )?;
                        *self.state = ConnectionPointInTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = ConnectionPointInTypeContentDeserializerState::Connection(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_expression<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<::std::string::String>,
                output: DeserializerOutput<'de, ::std::string::String>,
                fallback: &mut Option<ConnectionPointInTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = ConnectionPointInTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            ConnectionPointInTypeContentDeserializerState::Expression(values, None)
                        }
                        Some(ConnectionPointInTypeContentDeserializerState::Expression(
                            _,
                            Some(deserializer),
                        )) => ConnectionPointInTypeContentDeserializerState::Expression(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(ConnectionPointInTypeContentDeserializerState::Expression(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        ConnectionPointInTypeContentDeserializer::store_expression(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ConnectionPointInTypeContentDeserializer::store_expression(
                            &mut values,
                            data,
                        )?;
                        let data = ConnectionPointInTypeContentDeserializer::finish_state(
                            reader,
                            ConnectionPointInTypeContentDeserializerState::Expression(values, None),
                        )?;
                        *self.state = ConnectionPointInTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = ConnectionPointInTypeContentDeserializerState::Expression(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::AddDataType>,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<ConnectionPointInTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = ConnectionPointInTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            ConnectionPointInTypeContentDeserializerState::AddData(values, None)
                        }
                        Some(ConnectionPointInTypeContentDeserializerState::AddData(
                            _,
                            Some(deserializer),
                        )) => ConnectionPointInTypeContentDeserializerState::AddData(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(ConnectionPointInTypeContentDeserializerState::AddData(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        ConnectionPointInTypeContentDeserializer::store_add_data(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ConnectionPointInTypeContentDeserializer::store_add_data(
                            &mut values,
                            data,
                        )?;
                        let data = ConnectionPointInTypeContentDeserializer::finish_state(
                            reader,
                            ConnectionPointInTypeContentDeserializerState::AddData(values, None),
                        )?;
                        *self.state = ConnectionPointInTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = ConnectionPointInTypeContentDeserializerState::AddData(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ConnectionPointInTypeContent>
            for Box<ConnectionPointInTypeContentDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ConnectionPointInTypeContent>
            where
                R: DeserializeReader,
            {
                let deserializer = Box::new(ConnectionPointInTypeContentDeserializer {
                    state: Box::new(ConnectionPointInTypeContentDeserializerState::Init__),
                });
                let mut output = deserializer.next(reader, event)?;
                output.artifact = match output.artifact {
                    DeserializerArtifact::Deserializer(x)
                        if matches!(
                            &*x.state,
                            ConnectionPointInTypeContentDeserializerState::Init__
                        ) =>
                    {
                        DeserializerArtifact::None
                    }
                    artifact => artifact,
                };
                Ok(output)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ConnectionPointInTypeContent>
            where
                R: DeserializeReader,
            {
                use ConnectionPointInTypeContentDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::RelPosition(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_rel_position(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Connection(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Expression(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_expression(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AddData(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (state, event @ Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(
                                    ConnectionPointInTypeContentDeserializer::finish_state(
                                        reader, state,
                                    )?,
                                ),
                                event: DeserializerEvent::Continue(event),
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            match self.find_suitable(reader, event, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::RelPosition(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"relPosition",
                                false,
                            )?;
                            match self.handle_rel_position(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Connection(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connection",
                                false,
                            )?;
                            match self.handle_connection(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Expression(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"expression",
                                false,
                            )?;
                            match self.handle_expression(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AddData(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (s @ S::Done__(_), event) => {
                            *self.state = s;
                            break (DeserializerEvent::Continue(event), false);
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = if matches!(&*self.state, S::Done__(_)) {
                    DeserializerArtifact::Data(self.finish(reader)?)
                } else {
                    DeserializerArtifact::Deserializer(self)
                };
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(self, reader: &R) -> Result<super::ConnectionPointInTypeContent, Error>
            where
                R: DeserializeReader,
            {
                ConnectionPointInTypeContentDeserializer::finish_state(reader, *self.state)
            }
        }
        #[derive(Debug)]
        pub struct ConnectionPointOutTypeDeserializer {
            global_id: Option<::std::string::String>,
            rel_position: Option<super::PositionType>,
            expression: Option<::std::string::String>,
            add_data: Option<super::AddDataType>,
            state: Box<ConnectionPointOutTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ConnectionPointOutTypeDeserializerState {
            Init__,
            RelPosition(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            Expression(Option<<::std::string::String as WithDeserializer>::Deserializer>),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl ConnectionPointOutTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    global_id: global_id,
                    rel_position: None,
                    expression: None,
                    add_data: None,
                    state: Box::new(ConnectionPointOutTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ConnectionPointOutTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ConnectionPointOutTypeDeserializerState as S;
                match state {
                    S::RelPosition(Some(deserializer)) => {
                        self.store_rel_position(deserializer.finish(reader)?)?
                    }
                    S::Expression(Some(deserializer)) => {
                        self.store_expression(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_rel_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.rel_position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"relPosition",
                    )))?;
                }
                self.rel_position = Some(value);
                Ok(())
            }
            fn store_expression(&mut self, value: ::std::string::String) -> Result<(), Error> {
                if self.expression.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"expression",
                    )))?;
                }
                self.expression = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn handle_rel_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<ConnectionPointOutTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(ConnectionPointOutTypeDeserializerState::RelPosition(None));
                    *self.state = ConnectionPointOutTypeDeserializerState::Expression(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_rel_position(data)?;
                        *self.state = ConnectionPointOutTypeDeserializerState::Expression(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ConnectionPointOutTypeDeserializerState::RelPosition(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    ConnectionPointOutTypeDeserializerState::Expression(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ConnectionPointOutTypeDeserializerState::RelPosition(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_expression<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, ::std::string::String>,
                fallback: &mut Option<ConnectionPointOutTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(ConnectionPointOutTypeDeserializerState::Expression(None));
                    *self.state = ConnectionPointOutTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_expression(data)?;
                        *self.state = ConnectionPointOutTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ConnectionPointOutTypeDeserializerState::Expression(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    ConnectionPointOutTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ConnectionPointOutTypeDeserializerState::Expression(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<ConnectionPointOutTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(ConnectionPointOutTypeDeserializerState::AddData(None));
                    *self.state = ConnectionPointOutTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = ConnectionPointOutTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ConnectionPointOutTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = ConnectionPointOutTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ConnectionPointOutTypeDeserializerState::AddData(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ConnectionPointOutType>
            for Box<ConnectionPointOutTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ConnectionPointOutType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ConnectionPointOutTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ConnectionPointOutType>
            where
                R: DeserializeReader,
            {
                use ConnectionPointOutTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::RelPosition(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_rel_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Expression(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_expression(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                ConnectionPointOutTypeDeserializerState::RelPosition(None);
                            event
                        }
                        (S::RelPosition(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"relPosition",
                                false,
                            )?;
                            match self.handle_rel_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Expression(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"expression",
                                false,
                            )?;
                            match self.handle_expression(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::ConnectionPointOutType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ConnectionPointOutTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ConnectionPointOutType {
                    global_id: self.global_id,
                    rel_position: self.rel_position,
                    expression: self.expression,
                    add_data: self.add_data,
                })
            }
        }
        #[derive(Debug)]
        pub struct DataTypeDeserializer {
            state: Box<DataTypeDeserializerState>,
        }
        #[derive(Debug)]
        pub enum DataTypeDeserializerState {
            Init__,
            Bool(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Byte(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Word(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Dword(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Lword(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Sint(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Int(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Dint(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Lint(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Usint(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Uint(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Udint(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Ulint(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Real(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Lreal(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Time(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Date(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Dt(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Tod(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            String(
                Option<super::StringElementType>,
                Option<<super::StringElementType as WithDeserializer>::Deserializer>,
            ),
            Wstring(
                Option<super::StringElementType>,
                Option<<super::StringElementType as WithDeserializer>::Deserializer>,
            ),
            Any(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            AnyDerived(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            AnyElementary(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            AnyMagnitude(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            AnyNum(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            AnyReal(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            AnyInt(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            AnyBit(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            AnyString(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            AnyDate(
                Option<super::super::xs::AnyType>,
                Option<<super::super::xs::AnyType as WithDeserializer>::Deserializer>,
            ),
            Array(
                Option<super::ArrayElementType>,
                Option<<super::ArrayElementType as WithDeserializer>::Deserializer>,
            ),
            Derived(
                Option<super::DerivedElementType>,
                Option<<super::DerivedElementType as WithDeserializer>::Deserializer>,
            ),
            Enum(
                Option<super::EnumElementType>,
                Option<<super::EnumElementType as WithDeserializer>::Deserializer>,
            ),
            Struct(
                Option<super::VarListPlainType>,
                Option<<super::VarListPlainType as WithDeserializer>::Deserializer>,
            ),
            SubrangeSigned(
                Option<super::SubrangeSignedElementType>,
                Option<<super::SubrangeSignedElementType as WithDeserializer>::Deserializer>,
            ),
            SubrangeUnsigned(
                Option<super::SubrangeSignedElementType>,
                Option<<super::SubrangeSignedElementType as WithDeserializer>::Deserializer>,
            ),
            Pointer(
                Option<super::PointerElementType>,
                Option<<super::PointerElementType as WithDeserializer>::Deserializer>,
            ),
            Done__(super::DataType),
            Unknown__,
        }
        impl DataTypeDeserializer {
            fn find_suitable<'de, R>(
                &mut self,
                reader: &R,
                event: Event<'de>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                if let Event::Start(x) | Event::Empty(x) = &event {
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"BOOL")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_bool(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"BYTE")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_byte(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"WORD")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_word(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"DWORD")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_dword(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"LWORD")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_lword(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"SINT")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_sint(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"INT")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_int(reader, Default::default(), output, &mut *fallback);
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"DINT")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_dint(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"LINT")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_lint(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"USINT")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_usint(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"UINT")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_uint(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"UDINT")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_udint(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"ULINT")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_ulint(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"REAL")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_real(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"LREAL")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_lreal(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"TIME")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_time(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"DATE")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_date(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"DT")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_dt(reader, Default::default(), output, &mut *fallback);
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"TOD")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_tod(reader, Default::default(), output, &mut *fallback);
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"string")
                    ) {
                        let output =
                            <super::StringElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_string(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"wstring")
                    ) {
                        let output =
                            <super::StringElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_wstring(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"ANY")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_any(reader, Default::default(), output, &mut *fallback);
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"ANY_DERIVED")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_any_derived(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"ANY_ELEMENTARY")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_any_elementary(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"ANY_MAGNITUDE")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_any_magnitude(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"ANY_NUM")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_any_num(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"ANY_REAL")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_any_real(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"ANY_INT")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_any_int(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"ANY_BIT")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_any_bit(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"ANY_STRING")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_any_string(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"ANY_DATE")
                    ) {
                        let output =
                            <super::super::xs::AnyType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_any_date(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"array")
                    ) {
                        let output =
                            <super::ArrayElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_array(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"derived")
                    ) {
                        let output =
                            <super::DerivedElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_derived(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"enum")
                    ) {
                        let output =
                            <super::EnumElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_enum_(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"struct")
                    ) {
                        let output =
                            <super::VarListPlainType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_struct_(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"subrangeSigned")
                    ) {
                        let output = < super :: SubrangeSignedElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_subrange_signed(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"subrangeUnsigned")
                    ) {
                        let output = < super :: SubrangeSignedElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_subrange_unsigned(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"pointer")
                    ) {
                        let output =
                            <super::PointerElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_pointer(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                }
                *self.state = fallback.take().unwrap_or(DataTypeDeserializerState::Init__);
                Ok(ElementHandlerOutput::return_to_parent(event, false))
            }
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    state: Box::new(DataTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                reader: &R,
                state: DataTypeDeserializerState,
            ) -> Result<super::DataType, Error>
            where
                R: DeserializeReader,
            {
                use DataTypeDeserializerState as S;
                match state {
                    S::Init__ => Err(ErrorKind::MissingContent.into()),
                    S::Bool(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_bool(&mut values, value)?;
                        }
                        Ok(super::DataType::Bool(
                            values.ok_or_else(|| ErrorKind::MissingElement("BOOL".into()))?,
                        ))
                    }
                    S::Byte(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_byte(&mut values, value)?;
                        }
                        Ok(super::DataType::Byte(
                            values.ok_or_else(|| ErrorKind::MissingElement("BYTE".into()))?,
                        ))
                    }
                    S::Word(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_word(&mut values, value)?;
                        }
                        Ok(super::DataType::Word(
                            values.ok_or_else(|| ErrorKind::MissingElement("WORD".into()))?,
                        ))
                    }
                    S::Dword(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_dword(&mut values, value)?;
                        }
                        Ok(super::DataType::Dword(values.ok_or_else(|| {
                            ErrorKind::MissingElement("DWORD".into())
                        })?))
                    }
                    S::Lword(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_lword(&mut values, value)?;
                        }
                        Ok(super::DataType::Lword(values.ok_or_else(|| {
                            ErrorKind::MissingElement("LWORD".into())
                        })?))
                    }
                    S::Sint(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_sint(&mut values, value)?;
                        }
                        Ok(super::DataType::Sint(
                            values.ok_or_else(|| ErrorKind::MissingElement("SINT".into()))?,
                        ))
                    }
                    S::Int(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_int(&mut values, value)?;
                        }
                        Ok(super::DataType::Int(
                            values.ok_or_else(|| ErrorKind::MissingElement("INT".into()))?,
                        ))
                    }
                    S::Dint(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_dint(&mut values, value)?;
                        }
                        Ok(super::DataType::Dint(
                            values.ok_or_else(|| ErrorKind::MissingElement("DINT".into()))?,
                        ))
                    }
                    S::Lint(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_lint(&mut values, value)?;
                        }
                        Ok(super::DataType::Lint(
                            values.ok_or_else(|| ErrorKind::MissingElement("LINT".into()))?,
                        ))
                    }
                    S::Usint(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_usint(&mut values, value)?;
                        }
                        Ok(super::DataType::Usint(values.ok_or_else(|| {
                            ErrorKind::MissingElement("USINT".into())
                        })?))
                    }
                    S::Uint(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_uint(&mut values, value)?;
                        }
                        Ok(super::DataType::Uint(
                            values.ok_or_else(|| ErrorKind::MissingElement("UINT".into()))?,
                        ))
                    }
                    S::Udint(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_udint(&mut values, value)?;
                        }
                        Ok(super::DataType::Udint(values.ok_or_else(|| {
                            ErrorKind::MissingElement("UDINT".into())
                        })?))
                    }
                    S::Ulint(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_ulint(&mut values, value)?;
                        }
                        Ok(super::DataType::Ulint(values.ok_or_else(|| {
                            ErrorKind::MissingElement("ULINT".into())
                        })?))
                    }
                    S::Real(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_real(&mut values, value)?;
                        }
                        Ok(super::DataType::Real(
                            values.ok_or_else(|| ErrorKind::MissingElement("REAL".into()))?,
                        ))
                    }
                    S::Lreal(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_lreal(&mut values, value)?;
                        }
                        Ok(super::DataType::Lreal(values.ok_or_else(|| {
                            ErrorKind::MissingElement("LREAL".into())
                        })?))
                    }
                    S::Time(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_time(&mut values, value)?;
                        }
                        Ok(super::DataType::Time(
                            values.ok_or_else(|| ErrorKind::MissingElement("TIME".into()))?,
                        ))
                    }
                    S::Date(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_date(&mut values, value)?;
                        }
                        Ok(super::DataType::Date(
                            values.ok_or_else(|| ErrorKind::MissingElement("DATE".into()))?,
                        ))
                    }
                    S::Dt(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_dt(&mut values, value)?;
                        }
                        Ok(super::DataType::Dt(
                            values.ok_or_else(|| ErrorKind::MissingElement("DT".into()))?,
                        ))
                    }
                    S::Tod(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_tod(&mut values, value)?;
                        }
                        Ok(super::DataType::Tod(
                            values.ok_or_else(|| ErrorKind::MissingElement("TOD".into()))?,
                        ))
                    }
                    S::String(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_string(&mut values, value)?;
                        }
                        Ok(super::DataType::String(values.ok_or_else(|| {
                            ErrorKind::MissingElement("string".into())
                        })?))
                    }
                    S::Wstring(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_wstring(&mut values, value)?;
                        }
                        Ok(super::DataType::Wstring(values.ok_or_else(|| {
                            ErrorKind::MissingElement("wstring".into())
                        })?))
                    }
                    S::Any(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_any(&mut values, value)?;
                        }
                        Ok(super::DataType::Any(
                            values.ok_or_else(|| ErrorKind::MissingElement("ANY".into()))?,
                        ))
                    }
                    S::AnyDerived(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_any_derived(&mut values, value)?;
                        }
                        Ok(super::DataType::AnyDerived(values.ok_or_else(|| {
                            ErrorKind::MissingElement("ANY_DERIVED".into())
                        })?))
                    }
                    S::AnyElementary(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_any_elementary(&mut values, value)?;
                        }
                        Ok(super::DataType::AnyElementary(values.ok_or_else(|| {
                            ErrorKind::MissingElement("ANY_ELEMENTARY".into())
                        })?))
                    }
                    S::AnyMagnitude(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_any_magnitude(&mut values, value)?;
                        }
                        Ok(super::DataType::AnyMagnitude(values.ok_or_else(|| {
                            ErrorKind::MissingElement("ANY_MAGNITUDE".into())
                        })?))
                    }
                    S::AnyNum(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_any_num(&mut values, value)?;
                        }
                        Ok(super::DataType::AnyNum(values.ok_or_else(|| {
                            ErrorKind::MissingElement("ANY_NUM".into())
                        })?))
                    }
                    S::AnyReal(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_any_real(&mut values, value)?;
                        }
                        Ok(super::DataType::AnyReal(values.ok_or_else(|| {
                            ErrorKind::MissingElement("ANY_REAL".into())
                        })?))
                    }
                    S::AnyInt(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_any_int(&mut values, value)?;
                        }
                        Ok(super::DataType::AnyInt(values.ok_or_else(|| {
                            ErrorKind::MissingElement("ANY_INT".into())
                        })?))
                    }
                    S::AnyBit(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_any_bit(&mut values, value)?;
                        }
                        Ok(super::DataType::AnyBit(values.ok_or_else(|| {
                            ErrorKind::MissingElement("ANY_BIT".into())
                        })?))
                    }
                    S::AnyString(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_any_string(&mut values, value)?;
                        }
                        Ok(super::DataType::AnyString(values.ok_or_else(|| {
                            ErrorKind::MissingElement("ANY_STRING".into())
                        })?))
                    }
                    S::AnyDate(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_any_date(&mut values, value)?;
                        }
                        Ok(super::DataType::AnyDate(values.ok_or_else(|| {
                            ErrorKind::MissingElement("ANY_DATE".into())
                        })?))
                    }
                    S::Array(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_array(&mut values, value)?;
                        }
                        Ok(super::DataType::Array(Box::new(values.ok_or_else(
                            || ErrorKind::MissingElement("array".into()),
                        )?)))
                    }
                    S::Derived(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_derived(&mut values, value)?;
                        }
                        Ok(super::DataType::Derived(values.ok_or_else(|| {
                            ErrorKind::MissingElement("derived".into())
                        })?))
                    }
                    S::Enum(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_enum_(&mut values, value)?;
                        }
                        Ok(super::DataType::Enum(Box::new(values.ok_or_else(
                            || ErrorKind::MissingElement("enum".into()),
                        )?)))
                    }
                    S::Struct(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_struct_(&mut values, value)?;
                        }
                        Ok(super::DataType::Struct(values.ok_or_else(|| {
                            ErrorKind::MissingElement("struct".into())
                        })?))
                    }
                    S::SubrangeSigned(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_subrange_signed(&mut values, value)?;
                        }
                        Ok(super::DataType::SubrangeSigned(Box::new(
                            values.ok_or_else(|| {
                                ErrorKind::MissingElement("subrangeSigned".into())
                            })?,
                        )))
                    }
                    S::SubrangeUnsigned(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_subrange_unsigned(&mut values, value)?;
                        }
                        Ok(super::DataType::SubrangeUnsigned(Box::new(
                            values.ok_or_else(|| {
                                ErrorKind::MissingElement("subrangeUnsigned".into())
                            })?,
                        )))
                    }
                    S::Pointer(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            DataTypeDeserializer::store_pointer(&mut values, value)?;
                        }
                        Ok(super::DataType::Pointer(Box::new(values.ok_or_else(
                            || ErrorKind::MissingElement("pointer".into()),
                        )?)))
                    }
                    S::Done__(data) => Ok(data),
                    S::Unknown__ => unreachable!(),
                }
            }
            fn store_bool(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"BOOL")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_byte(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"BYTE")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_word(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"WORD")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_dword(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"DWORD",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_lword(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"LWORD",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_sint(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"SINT")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_int(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"INT")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_dint(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"DINT")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_lint(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"LINT")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_usint(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"USINT",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_uint(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"UINT")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_udint(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"UDINT",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_ulint(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"ULINT",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_real(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"REAL")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_lreal(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"LREAL",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_time(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"TIME")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_date(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"DATE")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_dt(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"DT")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_tod(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"TOD")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_string(
                values: &mut Option<super::StringElementType>,
                value: super::StringElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"string",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_wstring(
                values: &mut Option<super::StringElementType>,
                value: super::StringElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"wstring",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_any(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"ANY")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_any_derived(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"ANY_DERIVED",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_any_elementary(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"ANY_ELEMENTARY",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_any_magnitude(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"ANY_MAGNITUDE",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_any_num(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"ANY_NUM",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_any_real(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"ANY_REAL",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_any_int(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"ANY_INT",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_any_bit(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"ANY_BIT",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_any_string(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"ANY_STRING",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_any_date(
                values: &mut Option<super::super::xs::AnyType>,
                value: super::super::xs::AnyType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"ANY_DATE",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_array(
                values: &mut Option<super::ArrayElementType>,
                value: super::ArrayElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"array",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_derived(
                values: &mut Option<super::DerivedElementType>,
                value: super::DerivedElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"derived",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_enum_(
                values: &mut Option<super::EnumElementType>,
                value: super::EnumElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"enum")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_struct_(
                values: &mut Option<super::VarListPlainType>,
                value: super::VarListPlainType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"struct",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_subrange_signed(
                values: &mut Option<super::SubrangeSignedElementType>,
                value: super::SubrangeSignedElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"subrangeSigned",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_subrange_unsigned(
                values: &mut Option<super::SubrangeSignedElementType>,
                value: super::SubrangeSignedElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"subrangeUnsigned",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_pointer(
                values: &mut Option<super::PointerElementType>,
                value: super::PointerElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"pointer",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn handle_bool<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Bool(values, None),
                        Some(DataTypeDeserializerState::Bool(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Bool(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Bool(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_bool(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_bool(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Bool(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Bool(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_byte<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Byte(values, None),
                        Some(DataTypeDeserializerState::Byte(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Byte(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Byte(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_byte(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_byte(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Byte(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Byte(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_word<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Word(values, None),
                        Some(DataTypeDeserializerState::Word(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Word(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Word(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_word(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_word(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Word(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Word(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_dword<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Dword(values, None),
                        Some(DataTypeDeserializerState::Dword(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Dword(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Dword(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_dword(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_dword(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Dword(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Dword(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_lword<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Lword(values, None),
                        Some(DataTypeDeserializerState::Lword(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Lword(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Lword(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_lword(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_lword(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Lword(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Lword(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_sint<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Sint(values, None),
                        Some(DataTypeDeserializerState::Sint(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Sint(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Sint(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_sint(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_sint(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Sint(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Sint(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_int<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Int(values, None),
                        Some(DataTypeDeserializerState::Int(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Int(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Int(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_int(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_int(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Int(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Int(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_dint<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Dint(values, None),
                        Some(DataTypeDeserializerState::Dint(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Dint(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Dint(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_dint(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_dint(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Dint(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Dint(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_lint<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Lint(values, None),
                        Some(DataTypeDeserializerState::Lint(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Lint(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Lint(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_lint(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_lint(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Lint(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Lint(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_usint<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Usint(values, None),
                        Some(DataTypeDeserializerState::Usint(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Usint(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Usint(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_usint(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_usint(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Usint(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Usint(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_uint<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Uint(values, None),
                        Some(DataTypeDeserializerState::Uint(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Uint(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Uint(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_uint(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_uint(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Uint(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Uint(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_udint<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Udint(values, None),
                        Some(DataTypeDeserializerState::Udint(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Udint(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Udint(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_udint(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_udint(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Udint(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Udint(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_ulint<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Ulint(values, None),
                        Some(DataTypeDeserializerState::Ulint(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Ulint(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Ulint(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_ulint(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_ulint(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Ulint(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Ulint(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_real<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Real(values, None),
                        Some(DataTypeDeserializerState::Real(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Real(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Real(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_real(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_real(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Real(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Real(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_lreal<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Lreal(values, None),
                        Some(DataTypeDeserializerState::Lreal(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Lreal(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Lreal(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_lreal(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_lreal(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Lreal(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Lreal(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_time<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Time(values, None),
                        Some(DataTypeDeserializerState::Time(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Time(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Time(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_time(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_time(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Time(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Time(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_date<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Date(values, None),
                        Some(DataTypeDeserializerState::Date(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Date(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Date(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_date(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_date(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Date(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Date(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_dt<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Dt(values, None),
                        Some(DataTypeDeserializerState::Dt(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Dt(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Dt(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_dt(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_dt(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Dt(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Dt(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_tod<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Tod(values, None),
                        Some(DataTypeDeserializerState::Tod(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Tod(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Tod(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_tod(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_tod(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Tod(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Tod(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_string<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::StringElementType>,
                output: DeserializerOutput<'de, super::StringElementType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::String(values, None),
                        Some(DataTypeDeserializerState::String(_, Some(deserializer))) => {
                            DataTypeDeserializerState::String(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::String(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_string(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_string(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::String(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::String(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_wstring<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::StringElementType>,
                output: DeserializerOutput<'de, super::StringElementType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Wstring(values, None),
                        Some(DataTypeDeserializerState::Wstring(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Wstring(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Wstring(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_wstring(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_wstring(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Wstring(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            DataTypeDeserializerState::Wstring(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_any<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Any(values, None),
                        Some(DataTypeDeserializerState::Any(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Any(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Any(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_any(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_any(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Any(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Any(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_any_derived<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::AnyDerived(values, None),
                        Some(DataTypeDeserializerState::AnyDerived(_, Some(deserializer))) => {
                            DataTypeDeserializerState::AnyDerived(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::AnyDerived(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_any_derived(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_any_derived(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::AnyDerived(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            DataTypeDeserializerState::AnyDerived(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_any_elementary<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::AnyElementary(values, None),
                        Some(DataTypeDeserializerState::AnyElementary(_, Some(deserializer))) => {
                            DataTypeDeserializerState::AnyElementary(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::AnyElementary(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_any_elementary(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_any_elementary(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::AnyElementary(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            DataTypeDeserializerState::AnyElementary(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_any_magnitude<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::AnyMagnitude(values, None),
                        Some(DataTypeDeserializerState::AnyMagnitude(_, Some(deserializer))) => {
                            DataTypeDeserializerState::AnyMagnitude(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::AnyMagnitude(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_any_magnitude(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_any_magnitude(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::AnyMagnitude(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            DataTypeDeserializerState::AnyMagnitude(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_any_num<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::AnyNum(values, None),
                        Some(DataTypeDeserializerState::AnyNum(_, Some(deserializer))) => {
                            DataTypeDeserializerState::AnyNum(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::AnyNum(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_any_num(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_any_num(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::AnyNum(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::AnyNum(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_any_real<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::AnyReal(values, None),
                        Some(DataTypeDeserializerState::AnyReal(_, Some(deserializer))) => {
                            DataTypeDeserializerState::AnyReal(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::AnyReal(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_any_real(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_any_real(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::AnyReal(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            DataTypeDeserializerState::AnyReal(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_any_int<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::AnyInt(values, None),
                        Some(DataTypeDeserializerState::AnyInt(_, Some(deserializer))) => {
                            DataTypeDeserializerState::AnyInt(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::AnyInt(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_any_int(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_any_int(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::AnyInt(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::AnyInt(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_any_bit<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::AnyBit(values, None),
                        Some(DataTypeDeserializerState::AnyBit(_, Some(deserializer))) => {
                            DataTypeDeserializerState::AnyBit(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::AnyBit(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_any_bit(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_any_bit(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::AnyBit(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::AnyBit(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_any_string<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::AnyString(values, None),
                        Some(DataTypeDeserializerState::AnyString(_, Some(deserializer))) => {
                            DataTypeDeserializerState::AnyString(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::AnyString(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_any_string(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_any_string(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::AnyString(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            DataTypeDeserializerState::AnyString(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_any_date<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::super::xs::AnyType>,
                output: DeserializerOutput<'de, super::super::xs::AnyType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::AnyDate(values, None),
                        Some(DataTypeDeserializerState::AnyDate(_, Some(deserializer))) => {
                            DataTypeDeserializerState::AnyDate(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::AnyDate(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_any_date(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_any_date(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::AnyDate(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            DataTypeDeserializerState::AnyDate(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_array<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ArrayElementType>,
                output: DeserializerOutput<'de, super::ArrayElementType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Array(values, None),
                        Some(DataTypeDeserializerState::Array(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Array(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Array(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_array(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_array(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Array(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Array(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_derived<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::DerivedElementType>,
                output: DeserializerOutput<'de, super::DerivedElementType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Derived(values, None),
                        Some(DataTypeDeserializerState::Derived(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Derived(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Derived(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_derived(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_derived(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Derived(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            DataTypeDeserializerState::Derived(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_enum_<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::EnumElementType>,
                output: DeserializerOutput<'de, super::EnumElementType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Enum(values, None),
                        Some(DataTypeDeserializerState::Enum(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Enum(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Enum(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_enum_(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_enum_(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Enum(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Enum(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_struct_<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::VarListPlainType>,
                output: DeserializerOutput<'de, super::VarListPlainType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Struct(values, None),
                        Some(DataTypeDeserializerState::Struct(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Struct(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Struct(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_struct_(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_struct_(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Struct(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = DataTypeDeserializerState::Struct(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_subrange_signed<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::SubrangeSignedElementType>,
                output: DeserializerOutput<'de, super::SubrangeSignedElementType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::SubrangeSigned(values, None),
                        Some(DataTypeDeserializerState::SubrangeSigned(_, Some(deserializer))) => {
                            DataTypeDeserializerState::SubrangeSigned(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::SubrangeSigned(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_subrange_signed(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_subrange_signed(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::SubrangeSigned(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            DataTypeDeserializerState::SubrangeSigned(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_subrange_unsigned<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::SubrangeSignedElementType>,
                output: DeserializerOutput<'de, super::SubrangeSignedElementType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::SubrangeUnsigned(values, None),
                        Some(DataTypeDeserializerState::SubrangeUnsigned(
                            _,
                            Some(deserializer),
                        )) => {
                            DataTypeDeserializerState::SubrangeUnsigned(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::SubrangeUnsigned(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_subrange_unsigned(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_subrange_unsigned(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::SubrangeUnsigned(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            DataTypeDeserializerState::SubrangeUnsigned(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_pointer<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::PointerElementType>,
                output: DeserializerOutput<'de, super::PointerElementType>,
                fallback: &mut Option<DataTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = DataTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => DataTypeDeserializerState::Pointer(values, None),
                        Some(DataTypeDeserializerState::Pointer(_, Some(deserializer))) => {
                            DataTypeDeserializerState::Pointer(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(DataTypeDeserializerState::Pointer(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        DataTypeDeserializer::store_pointer(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        DataTypeDeserializer::store_pointer(&mut values, data)?;
                        *self.state = DataTypeDeserializerState::Pointer(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            DataTypeDeserializerState::Pointer(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::DataType> for Box<DataTypeDeserializer> {
            fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, super::DataType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    DataTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::DataType>
            where
                R: DeserializeReader,
            {
                use DataTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Bool(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_bool(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Byte(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_byte(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Word(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_word(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Dword(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_dword(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Lword(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_lword(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Sint(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_sint(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Int(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_int(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Dint(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_dint(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Lint(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_lint(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Usint(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_usint(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Uint(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_uint(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Udint(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_udint(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Ulint(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_ulint(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Real(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_real(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Lreal(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_lreal(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Time(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_time(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Date(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_date(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Dt(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_dt(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Tod(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_tod(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::String(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_string(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Wstring(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_wstring(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Any(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_any(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyDerived(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_any_derived(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyElementary(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_any_elementary(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyMagnitude(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_any_magnitude(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyNum(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_any_num(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyReal(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_any_real(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyInt(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_any_int(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyBit(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_any_bit(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyString(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_any_string(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyDate(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_any_date(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Array(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_array(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Derived(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_derived(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Enum(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_enum_(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Struct(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_struct_(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::SubrangeSigned(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_subrange_signed(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::SubrangeUnsigned(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_subrange_unsigned(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Pointer(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_pointer(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (state, Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(
                                    DataTypeDeserializer::finish_state(reader, state)?,
                                ),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            match self.find_suitable(reader, event, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Bool(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"BOOL",
                                true,
                            )?;
                            match self.handle_bool(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Byte(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"BYTE",
                                true,
                            )?;
                            match self.handle_byte(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Word(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"WORD",
                                true,
                            )?;
                            match self.handle_word(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Dword(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"DWORD",
                                true,
                            )?;
                            match self.handle_dword(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Lword(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"LWORD",
                                true,
                            )?;
                            match self.handle_lword(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Sint(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"SINT",
                                true,
                            )?;
                            match self.handle_sint(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Int(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"INT",
                                true,
                            )?;
                            match self.handle_int(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Dint(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"DINT",
                                true,
                            )?;
                            match self.handle_dint(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Lint(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"LINT",
                                true,
                            )?;
                            match self.handle_lint(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Usint(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"USINT",
                                true,
                            )?;
                            match self.handle_usint(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Uint(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"UINT",
                                true,
                            )?;
                            match self.handle_uint(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Udint(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"UDINT",
                                true,
                            )?;
                            match self.handle_udint(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Ulint(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"ULINT",
                                true,
                            )?;
                            match self.handle_ulint(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Real(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"REAL",
                                true,
                            )?;
                            match self.handle_real(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Lreal(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"LREAL",
                                true,
                            )?;
                            match self.handle_lreal(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Time(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"TIME",
                                true,
                            )?;
                            match self.handle_time(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Date(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"DATE",
                                true,
                            )?;
                            match self.handle_date(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Dt(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"DT",
                                true,
                            )?;
                            match self.handle_dt(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Tod(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"TOD",
                                true,
                            )?;
                            match self.handle_tod(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::String(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"string",
                                false,
                            )?;
                            match self.handle_string(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Wstring(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"wstring",
                                false,
                            )?;
                            match self.handle_wstring(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Any(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"ANY",
                                true,
                            )?;
                            match self.handle_any(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyDerived(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"ANY_DERIVED",
                                true,
                            )?;
                            match self.handle_any_derived(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyElementary(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"ANY_ELEMENTARY",
                                true,
                            )?;
                            match self.handle_any_elementary(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyMagnitude(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"ANY_MAGNITUDE",
                                true,
                            )?;
                            match self.handle_any_magnitude(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyNum(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"ANY_NUM",
                                true,
                            )?;
                            match self.handle_any_num(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyReal(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"ANY_REAL",
                                true,
                            )?;
                            match self.handle_any_real(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyInt(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"ANY_INT",
                                true,
                            )?;
                            match self.handle_any_int(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyBit(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"ANY_BIT",
                                true,
                            )?;
                            match self.handle_any_bit(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyString(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"ANY_STRING",
                                true,
                            )?;
                            match self.handle_any_string(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AnyDate(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"ANY_DATE",
                                true,
                            )?;
                            match self.handle_any_date(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Array(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"array",
                                false,
                            )?;
                            match self.handle_array(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Derived(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"derived",
                                true,
                            )?;
                            match self.handle_derived(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Enum(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"enum",
                                false,
                            )?;
                            match self.handle_enum_(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Struct(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"struct",
                                true,
                            )?;
                            match self.handle_struct_(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::SubrangeSigned(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"subrangeSigned",
                                false,
                            )?;
                            match self.handle_subrange_signed(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::SubrangeUnsigned(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"subrangeUnsigned",
                                false,
                            )?;
                            match self.handle_subrange_unsigned(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Pointer(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"pointer",
                                true,
                            )?;
                            match self.handle_pointer(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (s @ S::Done__(_), event) => {
                            *self.state = s;
                            break (DeserializerEvent::Continue(event), false);
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = if matches!(&*self.state, S::Done__(_)) {
                    DeserializerArtifact::Data(self.finish(reader)?)
                } else {
                    DeserializerArtifact::Deserializer(self)
                };
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(self, reader: &R) -> Result<super::DataType, Error>
            where
                R: DeserializeReader,
            {
                DataTypeDeserializer::finish_state(reader, *self.state)
            }
        }
        #[derive(Debug)]
        pub struct FormattedTextTypeDeserializer {
            any: Option<AnyElement>,
            state: Box<FormattedTextTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum FormattedTextTypeDeserializerState {
            Init__,
            Any(Option<<AnyElement as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl FormattedTextTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    any: None,
                    state: Box::new(FormattedTextTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: FormattedTextTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use FormattedTextTypeDeserializerState as S;
                match state {
                    S::Any(Some(deserializer)) => self.store_any(deserializer.finish(reader)?)?,
                    _ => (),
                }
                Ok(())
            }
            fn store_any(&mut self, value: AnyElement) -> Result<(), Error> {
                if self.any.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"any16",
                    )))?;
                }
                self.any = Some(value);
                Ok(())
            }
            fn handle_any<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, AnyElement>,
                fallback: &mut Option<FormattedTextTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.any.is_some() {
                        fallback.get_or_insert(FormattedTextTypeDeserializerState::Any(None));
                        *self.state = FormattedTextTypeDeserializerState::Done__;
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = FormattedTextTypeDeserializerState::Any(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_any(data)?;
                        *self.state = FormattedTextTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(FormattedTextTypeDeserializerState::Any(
                                    Some(deserializer),
                                ));
                                *self.state = FormattedTextTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    FormattedTextTypeDeserializerState::Any(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::FormattedTextType> for Box<FormattedTextTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::FormattedTextType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    FormattedTextTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::FormattedTextType>
            where
                R: DeserializeReader,
            {
                use FormattedTextTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let mut is_any_retry = false;
                let mut any_fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Any(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_any(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = FormattedTextTypeDeserializerState::Any(None);
                            event
                        }
                        (S::Any(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            if is_any_retry {
                                let output = <AnyElement as WithDeserializer>::Deserializer::init(
                                    reader, event,
                                )?;
                                match self.handle_any(reader, output, &mut fallback)? {
                                    ElementHandlerOutput::Continue { event, allow_any } => {
                                        allow_any_element = allow_any_element || allow_any;
                                        event
                                    }
                                    ElementHandlerOutput::Break { event, allow_any } => {
                                        break (event, allow_any)
                                    }
                                }
                            } else {
                                any_fallback.get_or_insert(S::Any(None));
                                *self.state = S::Done__;
                                event
                            }
                        }
                        (S::Done__, event) => {
                            if let Some(state) = any_fallback.take() {
                                is_any_retry = true;
                                *self.state = state;
                                event
                            } else {
                                fallback.get_or_insert(S::Done__);
                                break (DeserializerEvent::Continue(event), allow_any_element);
                            }
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::FormattedTextType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    FormattedTextTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::FormattedTextType {
                    any: self
                        .any
                        .ok_or_else(|| ErrorKind::MissingElement("any16".into()))?,
                })
            }
        }
        #[derive(Debug)]
        pub struct PositionTypeDeserializer {
            x: ::core::primitive::f64,
            y: ::core::primitive::f64,
            state: Box<PositionTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum PositionTypeDeserializerState {
            Init__,
            Unknown__,
        }
        impl PositionTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut x: Option<::core::primitive::f64> = None;
                let mut y: Option<::core::primitive::f64> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"x")
                    ) {
                        reader.read_attrib(&mut x, b"x", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"y")
                    ) {
                        reader.read_attrib(&mut y, b"y", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    x: x.ok_or_else(|| reader.map_error(ErrorKind::MissingAttribute("x".into())))?,
                    y: y.ok_or_else(|| reader.map_error(ErrorKind::MissingAttribute("y".into())))?,
                    state: Box::new(PositionTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: PositionTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                Ok(())
            }
        }
        impl<'de> Deserializer<'de, super::PositionType> for Box<PositionTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::PositionType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    PositionTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::PositionType>
            where
                R: DeserializeReader,
            {
                if let Event::End(_) = &event {
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(self.finish(reader)?),
                        event: DeserializerEvent::None,
                        allow_any: false,
                    })
                } else {
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event: DeserializerEvent::Break(event),
                        allow_any: false,
                    })
                }
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::PositionType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(&mut *self.state, PositionTypeDeserializerState::Unknown__);
                self.finish_state(reader, state)?;
                Ok(super::PositionType {
                    x: self.x,
                    y: self.y,
                })
            }
        }
        #[derive(Debug)]
        pub struct PouInstanceTypeDeserializer {
            name: ::std::string::String,
            type_name: ::std::string::String,
            global_id: Option<::std::string::String>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<PouInstanceTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum PouInstanceTypeDeserializerState {
            Init__,
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl PouInstanceTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                let mut type_name: Option<::std::string::String> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"typeName")
                    ) {
                        reader.read_attrib(&mut type_name, b"typeName", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    name: name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("name".into()))
                    })?,
                    type_name: type_name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("typeName".into()))
                    })?,
                    global_id: global_id,
                    add_data: None,
                    documentation: None,
                    state: Box::new(PouInstanceTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: PouInstanceTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use PouInstanceTypeDeserializerState as S;
                match state {
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<PouInstanceTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(PouInstanceTypeDeserializerState::AddData(None));
                    *self.state = PouInstanceTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = PouInstanceTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(PouInstanceTypeDeserializerState::AddData(
                                    Some(deserializer),
                                ));
                                *self.state = PouInstanceTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    PouInstanceTypeDeserializerState::AddData(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<PouInstanceTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(PouInstanceTypeDeserializerState::Documentation(None));
                    *self.state = PouInstanceTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = PouInstanceTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    PouInstanceTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = PouInstanceTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = PouInstanceTypeDeserializerState::Documentation(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::PouInstanceType> for Box<PouInstanceTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::PouInstanceType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    PouInstanceTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::PouInstanceType>
            where
                R: DeserializeReader,
            {
                use PouInstanceTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = PouInstanceTypeDeserializerState::AddData(None);
                            event
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::PouInstanceType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    PouInstanceTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::PouInstanceType {
                    name: self.name,
                    type_name: self.type_name,
                    global_id: self.global_id,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct ProjectElementTypeDeserializer {
            file_header: Option<super::ProjectFileHeaderElementType>,
            content_header: Option<super::ProjectContentHeaderElementType>,
            types: Option<super::ProjectTypesElementType>,
            instances: Option<super::ProjectInstancesElementType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<ProjectElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectElementTypeDeserializerState {
            Init__,
            FileHeader(
                Option<<super::ProjectFileHeaderElementType as WithDeserializer>::Deserializer>,
            ),
            ContentHeader(
                Option<<super::ProjectContentHeaderElementType as WithDeserializer>::Deserializer>,
            ),
            Types(Option<<super::ProjectTypesElementType as WithDeserializer>::Deserializer>),
            Instances(
                Option<<super::ProjectInstancesElementType as WithDeserializer>::Deserializer>,
            ),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl ProjectElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    file_header: None,
                    content_header: None,
                    types: None,
                    instances: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(ProjectElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectElementTypeDeserializerState as S;
                match state {
                    S::FileHeader(Some(deserializer)) => {
                        self.store_file_header(deserializer.finish(reader)?)?
                    }
                    S::ContentHeader(Some(deserializer)) => {
                        self.store_content_header(deserializer.finish(reader)?)?
                    }
                    S::Types(Some(deserializer)) => {
                        self.store_types(deserializer.finish(reader)?)?
                    }
                    S::Instances(Some(deserializer)) => {
                        self.store_instances(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_file_header(
                &mut self,
                value: super::ProjectFileHeaderElementType,
            ) -> Result<(), Error> {
                if self.file_header.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"fileHeader",
                    )))?;
                }
                self.file_header = Some(value);
                Ok(())
            }
            fn store_content_header(
                &mut self,
                value: super::ProjectContentHeaderElementType,
            ) -> Result<(), Error> {
                if self.content_header.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"contentHeader",
                    )))?;
                }
                self.content_header = Some(value);
                Ok(())
            }
            fn store_types(&mut self, value: super::ProjectTypesElementType) -> Result<(), Error> {
                if self.types.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"types",
                    )))?;
                }
                self.types = Some(value);
                Ok(())
            }
            fn store_instances(
                &mut self,
                value: super::ProjectInstancesElementType,
            ) -> Result<(), Error> {
                if self.instances.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"instances",
                    )))?;
                }
                self.instances = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_file_header<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ProjectFileHeaderElementType>,
                fallback: &mut Option<ProjectElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.file_header.is_some() {
                        fallback
                            .get_or_insert(ProjectElementTypeDeserializerState::FileHeader(None));
                        *self.state = ProjectElementTypeDeserializerState::ContentHeader(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = ProjectElementTypeDeserializerState::FileHeader(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_file_header(data)?;
                        *self.state = ProjectElementTypeDeserializerState::ContentHeader(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectElementTypeDeserializerState::FileHeader(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    ProjectElementTypeDeserializerState::ContentHeader(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ProjectElementTypeDeserializerState::FileHeader(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_content_header<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ProjectContentHeaderElementType>,
                fallback: &mut Option<ProjectElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.content_header.is_some() {
                        fallback.get_or_insert(ProjectElementTypeDeserializerState::ContentHeader(
                            None,
                        ));
                        *self.state = ProjectElementTypeDeserializerState::Types(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = ProjectElementTypeDeserializerState::ContentHeader(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_content_header(data)?;
                        *self.state = ProjectElementTypeDeserializerState::Types(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectElementTypeDeserializerState::ContentHeader(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = ProjectElementTypeDeserializerState::Types(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ProjectElementTypeDeserializerState::ContentHeader(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_types<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ProjectTypesElementType>,
                fallback: &mut Option<ProjectElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.types.is_some() {
                        fallback.get_or_insert(ProjectElementTypeDeserializerState::Types(None));
                        *self.state = ProjectElementTypeDeserializerState::Instances(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = ProjectElementTypeDeserializerState::Types(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_types(data)?;
                        *self.state = ProjectElementTypeDeserializerState::Instances(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(ProjectElementTypeDeserializerState::Types(
                                    Some(deserializer),
                                ));
                                *self.state = ProjectElementTypeDeserializerState::Instances(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ProjectElementTypeDeserializerState::Types(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_instances<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ProjectInstancesElementType>,
                fallback: &mut Option<ProjectElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.instances.is_some() {
                        fallback
                            .get_or_insert(ProjectElementTypeDeserializerState::Instances(None));
                        *self.state = ProjectElementTypeDeserializerState::AddData(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = ProjectElementTypeDeserializerState::Instances(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_instances(data)?;
                        *self.state = ProjectElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectElementTypeDeserializerState::Instances(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = ProjectElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ProjectElementTypeDeserializerState::Instances(Some(
                                    deserializer,
                                ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<ProjectElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(ProjectElementTypeDeserializerState::AddData(None));
                    *self.state = ProjectElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = ProjectElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    ProjectElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ProjectElementTypeDeserializerState::AddData(Some(
                                    deserializer,
                                ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<ProjectElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(ProjectElementTypeDeserializerState::Documentation(None));
                    *self.state = ProjectElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = ProjectElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = ProjectElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ProjectElementTypeDeserializerState::Documentation(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectElementType> for Box<ProjectElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ProjectElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectElementType>
            where
                R: DeserializeReader,
            {
                use ProjectElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::FileHeader(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_file_header(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ContentHeader(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_content_header(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Types(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_types(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Instances(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_instances(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = ProjectElementTypeDeserializerState::FileHeader(None);
                            event
                        }
                        (S::FileHeader(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"fileHeader",
                                false,
                            )?;
                            match self.handle_file_header(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ContentHeader(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"contentHeader",
                                false,
                            )?;
                            match self.handle_content_header(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Types(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"types",
                                true,
                            )?;
                            match self.handle_types(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Instances(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"instances",
                                true,
                            )?;
                            match self.handle_instances(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::ProjectElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ProjectElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ProjectElementType {
                    file_header: self
                        .file_header
                        .ok_or_else(|| ErrorKind::MissingElement("fileHeader".into()))?,
                    content_header: self
                        .content_header
                        .ok_or_else(|| ErrorKind::MissingElement("contentHeader".into()))?,
                    types: self
                        .types
                        .ok_or_else(|| ErrorKind::MissingElement("types".into()))?,
                    instances: self
                        .instances
                        .ok_or_else(|| ErrorKind::MissingElement("instances".into()))?,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct RangeSignedTypeDeserializer {
            lower: ::std::string::String,
            upper: ::std::string::String,
            state: Box<RangeSignedTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum RangeSignedTypeDeserializerState {
            Init__,
            Unknown__,
        }
        impl RangeSignedTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut lower: Option<::std::string::String> = None;
                let mut upper: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"lower")
                    ) {
                        reader.read_attrib(&mut lower, b"lower", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"upper")
                    ) {
                        reader.read_attrib(&mut upper, b"upper", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    lower: lower.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("lower".into()))
                    })?,
                    upper: upper.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("upper".into()))
                    })?,
                    state: Box::new(RangeSignedTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: RangeSignedTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                Ok(())
            }
        }
        impl<'de> Deserializer<'de, super::RangeSignedType> for Box<RangeSignedTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::RangeSignedType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    RangeSignedTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::RangeSignedType>
            where
                R: DeserializeReader,
            {
                if let Event::End(_) = &event {
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(self.finish(reader)?),
                        event: DeserializerEvent::None,
                        allow_any: false,
                    })
                } else {
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event: DeserializerEvent::Break(event),
                        allow_any: false,
                    })
                }
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::RangeSignedType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    RangeSignedTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::RangeSignedType {
                    lower: self.lower,
                    upper: self.upper,
                })
            }
        }
        #[derive(Debug)]
        pub struct ValueTypeDeserializer {
            state: Box<ValueTypeDeserializerState>,
        }
        #[derive(Debug)]
        pub enum ValueTypeDeserializerState {
            Init__,
            SimpleValue(
                Option<super::ValueSimpleValueElementType>,
                Option<<super::ValueSimpleValueElementType as WithDeserializer>::Deserializer>,
            ),
            ArrayValue(
                Option<super::ValueArrayValueElementType>,
                Option<<super::ValueArrayValueElementType as WithDeserializer>::Deserializer>,
            ),
            StructValue(
                Option<super::ValueStructValueElementType>,
                Option<<super::ValueStructValueElementType as WithDeserializer>::Deserializer>,
            ),
            Done__(super::ValueType),
            Unknown__,
        }
        impl ValueTypeDeserializer {
            fn find_suitable<'de, R>(
                &mut self,
                reader: &R,
                event: Event<'de>,
                fallback: &mut Option<ValueTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                if let Event::Start(x) | Event::Empty(x) = &event {
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"simpleValue")
                    ) {
                        let output = < super :: ValueSimpleValueElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_simple_value(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"arrayValue")
                    ) {
                        let output = < super :: ValueArrayValueElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_array_value(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"structValue")
                    ) {
                        let output = < super :: ValueStructValueElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_struct_value(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                }
                *self.state = fallback
                    .take()
                    .unwrap_or(ValueTypeDeserializerState::Init__);
                Ok(ElementHandlerOutput::return_to_parent(event, false))
            }
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    state: Box::new(ValueTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                reader: &R,
                state: ValueTypeDeserializerState,
            ) -> Result<super::ValueType, Error>
            where
                R: DeserializeReader,
            {
                use ValueTypeDeserializerState as S;
                match state {
                    S::Init__ => Err(ErrorKind::MissingContent.into()),
                    S::SimpleValue(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ValueTypeDeserializer::store_simple_value(&mut values, value)?;
                        }
                        Ok(super::ValueType::SimpleValue(values.ok_or_else(|| {
                            ErrorKind::MissingElement("simpleValue".into())
                        })?))
                    }
                    S::ArrayValue(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ValueTypeDeserializer::store_array_value(&mut values, value)?;
                        }
                        Ok(super::ValueType::ArrayValue(values.ok_or_else(|| {
                            ErrorKind::MissingElement("arrayValue".into())
                        })?))
                    }
                    S::StructValue(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ValueTypeDeserializer::store_struct_value(&mut values, value)?;
                        }
                        Ok(super::ValueType::StructValue(values.ok_or_else(|| {
                            ErrorKind::MissingElement("structValue".into())
                        })?))
                    }
                    S::Done__(data) => Ok(data),
                    S::Unknown__ => unreachable!(),
                }
            }
            fn store_simple_value(
                values: &mut Option<super::ValueSimpleValueElementType>,
                value: super::ValueSimpleValueElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"simpleValue",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_array_value(
                values: &mut Option<super::ValueArrayValueElementType>,
                value: super::ValueArrayValueElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"arrayValue",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_struct_value(
                values: &mut Option<super::ValueStructValueElementType>,
                value: super::ValueStructValueElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"structValue",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn handle_simple_value<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ValueSimpleValueElementType>,
                output: DeserializerOutput<'de, super::ValueSimpleValueElementType>,
                fallback: &mut Option<ValueTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = ValueTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => ValueTypeDeserializerState::SimpleValue(values, None),
                        Some(ValueTypeDeserializerState::SimpleValue(_, Some(deserializer))) => {
                            ValueTypeDeserializerState::SimpleValue(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(ValueTypeDeserializerState::SimpleValue(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        ValueTypeDeserializer::store_simple_value(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ValueTypeDeserializer::store_simple_value(&mut values, data)?;
                        *self.state = ValueTypeDeserializerState::SimpleValue(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            ValueTypeDeserializerState::SimpleValue(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_array_value<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ValueArrayValueElementType>,
                output: DeserializerOutput<'de, super::ValueArrayValueElementType>,
                fallback: &mut Option<ValueTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = ValueTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => ValueTypeDeserializerState::ArrayValue(values, None),
                        Some(ValueTypeDeserializerState::ArrayValue(_, Some(deserializer))) => {
                            ValueTypeDeserializerState::ArrayValue(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(ValueTypeDeserializerState::ArrayValue(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        ValueTypeDeserializer::store_array_value(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ValueTypeDeserializer::store_array_value(&mut values, data)?;
                        *self.state = ValueTypeDeserializerState::ArrayValue(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            ValueTypeDeserializerState::ArrayValue(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_struct_value<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ValueStructValueElementType>,
                output: DeserializerOutput<'de, super::ValueStructValueElementType>,
                fallback: &mut Option<ValueTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = ValueTypeDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => ValueTypeDeserializerState::StructValue(values, None),
                        Some(ValueTypeDeserializerState::StructValue(_, Some(deserializer))) => {
                            ValueTypeDeserializerState::StructValue(values, Some(deserializer))
                        }
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(ValueTypeDeserializerState::StructValue(_, Some(deserializer))) => {
                        let data = deserializer.finish(reader)?;
                        ValueTypeDeserializer::store_struct_value(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ValueTypeDeserializer::store_struct_value(&mut values, data)?;
                        *self.state = ValueTypeDeserializerState::StructValue(values, None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            ValueTypeDeserializerState::StructValue(values, Some(deserializer));
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ValueType> for Box<ValueTypeDeserializer> {
            fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, super::ValueType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ValueTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueType>
            where
                R: DeserializeReader,
            {
                use ValueTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::SimpleValue(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_simple_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::ArrayValue(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_array_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::StructValue(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_struct_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (state, Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(
                                    ValueTypeDeserializer::finish_state(reader, state)?,
                                ),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            match self.find_suitable(reader, event, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::SimpleValue(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"simpleValue",
                                false,
                            )?;
                            match self.handle_simple_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::ArrayValue(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"arrayValue",
                                false,
                            )?;
                            match self.handle_array_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::StructValue(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"structValue",
                                false,
                            )?;
                            match self.handle_struct_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (s @ S::Done__(_), event) => {
                            *self.state = s;
                            break (DeserializerEvent::Continue(event), false);
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = if matches!(&*self.state, S::Done__(_)) {
                    DeserializerArtifact::Data(self.finish(reader)?)
                } else {
                    DeserializerArtifact::Deserializer(self)
                };
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(self, reader: &R) -> Result<super::ValueType, Error>
            where
                R: DeserializeReader,
            {
                ValueTypeDeserializer::finish_state(reader, *self.state)
            }
        }
        #[derive(Debug)]
        pub struct VarListTypeDeserializer {
            name: Option<::std::string::String>,
            constant: ::core::primitive::bool,
            retain: ::core::primitive::bool,
            nonretain: ::core::primitive::bool,
            persistent: ::core::primitive::bool,
            nonpersistent: ::core::primitive::bool,
            variable: Vec<super::VarListPlainVariableElementType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<VarListTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum VarListTypeDeserializerState {
            Init__,
            Variable(
                Option<<super::VarListPlainVariableElementType as WithDeserializer>::Deserializer>,
            ),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl VarListTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                let mut constant: Option<::core::primitive::bool> = None;
                let mut retain: Option<::core::primitive::bool> = None;
                let mut nonretain: Option<::core::primitive::bool> = None;
                let mut persistent: Option<::core::primitive::bool> = None;
                let mut nonpersistent: Option<::core::primitive::bool> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"constant")
                    ) {
                        reader.read_attrib(&mut constant, b"constant", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"retain")
                    ) {
                        reader.read_attrib(&mut retain, b"retain", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"nonretain")
                    ) {
                        reader.read_attrib(&mut nonretain, b"nonretain", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"persistent")
                    ) {
                        reader.read_attrib(&mut persistent, b"persistent", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"nonpersistent")
                    ) {
                        reader.read_attrib(&mut nonpersistent, b"nonpersistent", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    name: name,
                    constant: constant.unwrap_or_else(super::VarListType::default_constant),
                    retain: retain.unwrap_or_else(super::VarListType::default_retain),
                    nonretain: nonretain.unwrap_or_else(super::VarListType::default_nonretain),
                    persistent: persistent.unwrap_or_else(super::VarListType::default_persistent),
                    nonpersistent: nonpersistent
                        .unwrap_or_else(super::VarListType::default_nonpersistent),
                    variable: Vec::new(),
                    add_data: None,
                    documentation: None,
                    state: Box::new(VarListTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: VarListTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use VarListTypeDeserializerState as S;
                match state {
                    S::Variable(Some(deserializer)) => {
                        self.store_variable(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_variable(
                &mut self,
                value: super::VarListPlainVariableElementType,
            ) -> Result<(), Error> {
                self.variable.push(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_variable<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::VarListPlainVariableElementType>,
                fallback: &mut Option<VarListTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(VarListTypeDeserializerState::Variable(None));
                    *self.state = VarListTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_variable(data)?;
                        *self.state = VarListTypeDeserializerState::Variable(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(VarListTypeDeserializerState::Variable(
                                    Some(deserializer),
                                ));
                                *self.state = VarListTypeDeserializerState::Variable(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    VarListTypeDeserializerState::Variable(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<VarListTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(VarListTypeDeserializerState::AddData(None));
                    *self.state = VarListTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = VarListTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(VarListTypeDeserializerState::AddData(
                                    Some(deserializer),
                                ));
                                *self.state = VarListTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    VarListTypeDeserializerState::AddData(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<VarListTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(VarListTypeDeserializerState::Documentation(None));
                    *self.state = VarListTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = VarListTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VarListTypeDeserializerState::Documentation(Some(deserializer)),
                                );
                                *self.state = VarListTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    VarListTypeDeserializerState::Documentation(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::VarListType> for Box<VarListTypeDeserializer> {
            fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, super::VarListType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    VarListTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::VarListType>
            where
                R: DeserializeReader,
            {
                use VarListTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Variable(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = VarListTypeDeserializerState::Variable(None);
                            event
                        }
                        (S::Variable(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"variable",
                                true,
                            )?;
                            match self.handle_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::VarListType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(&mut *self.state, VarListTypeDeserializerState::Unknown__);
                self.finish_state(reader, state)?;
                Ok(super::VarListType {
                    name: self.name,
                    constant: self.constant,
                    retain: self.retain,
                    nonretain: self.nonretain,
                    persistent: self.persistent,
                    nonpersistent: self.nonpersistent,
                    variable: self.variable,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct VarListAccessTypeDeserializer {
            access_variable: Vec<super::VarListAccessAccessVariableElementType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<VarListAccessTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum VarListAccessTypeDeserializerState {
            Init__ , AccessVariable (Option << super :: VarListAccessAccessVariableElementType as WithDeserializer > :: Deserializer >) , AddData (Option << super :: AddDataType as WithDeserializer > :: Deserializer >) , Documentation (Option << super :: FormattedTextType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl VarListAccessTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    access_variable: Vec::new(),
                    add_data: None,
                    documentation: None,
                    state: Box::new(VarListAccessTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: VarListAccessTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use VarListAccessTypeDeserializerState as S;
                match state {
                    S::AccessVariable(Some(deserializer)) => {
                        self.store_access_variable(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_access_variable(
                &mut self,
                value: super::VarListAccessAccessVariableElementType,
            ) -> Result<(), Error> {
                self.access_variable.push(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_access_variable<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::VarListAccessAccessVariableElementType>,
                fallback: &mut Option<VarListAccessTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(VarListAccessTypeDeserializerState::AccessVariable(None));
                    *self.state = VarListAccessTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_access_variable(data)?;
                        *self.state = VarListAccessTypeDeserializerState::AccessVariable(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VarListAccessTypeDeserializerState::AccessVariable(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    VarListAccessTypeDeserializerState::AccessVariable(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = VarListAccessTypeDeserializerState::AccessVariable(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<VarListAccessTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(VarListAccessTypeDeserializerState::AddData(None));
                    *self.state = VarListAccessTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = VarListAccessTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VarListAccessTypeDeserializerState::AddData(Some(deserializer)),
                                );
                                *self.state =
                                    VarListAccessTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    VarListAccessTypeDeserializerState::AddData(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<VarListAccessTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(VarListAccessTypeDeserializerState::Documentation(None));
                    *self.state = VarListAccessTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = VarListAccessTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VarListAccessTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = VarListAccessTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = VarListAccessTypeDeserializerState::Documentation(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::VarListAccessType> for Box<VarListAccessTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::VarListAccessType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    VarListAccessTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::VarListAccessType>
            where
                R: DeserializeReader,
            {
                use VarListAccessTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::AccessVariable(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_access_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = VarListAccessTypeDeserializerState::AccessVariable(None);
                            event
                        }
                        (S::AccessVariable(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"accessVariable",
                                true,
                            )?;
                            match self.handle_access_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::VarListAccessType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    VarListAccessTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::VarListAccessType {
                    access_variable: self.access_variable,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct VarListConfigTypeDeserializer {
            config_variable: Vec<super::VarListConfigConfigVariableElementType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<VarListConfigTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum VarListConfigTypeDeserializerState {
            Init__ , ConfigVariable (Option << super :: VarListConfigConfigVariableElementType as WithDeserializer > :: Deserializer >) , AddData (Option << super :: AddDataType as WithDeserializer > :: Deserializer >) , Documentation (Option << super :: FormattedTextType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl VarListConfigTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    config_variable: Vec::new(),
                    add_data: None,
                    documentation: None,
                    state: Box::new(VarListConfigTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: VarListConfigTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use VarListConfigTypeDeserializerState as S;
                match state {
                    S::ConfigVariable(Some(deserializer)) => {
                        self.store_config_variable(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_config_variable(
                &mut self,
                value: super::VarListConfigConfigVariableElementType,
            ) -> Result<(), Error> {
                self.config_variable.push(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_config_variable<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::VarListConfigConfigVariableElementType>,
                fallback: &mut Option<VarListConfigTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(VarListConfigTypeDeserializerState::ConfigVariable(None));
                    *self.state = VarListConfigTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_config_variable(data)?;
                        *self.state = VarListConfigTypeDeserializerState::ConfigVariable(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VarListConfigTypeDeserializerState::ConfigVariable(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    VarListConfigTypeDeserializerState::ConfigVariable(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = VarListConfigTypeDeserializerState::ConfigVariable(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<VarListConfigTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(VarListConfigTypeDeserializerState::AddData(None));
                    *self.state = VarListConfigTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = VarListConfigTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VarListConfigTypeDeserializerState::AddData(Some(deserializer)),
                                );
                                *self.state =
                                    VarListConfigTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    VarListConfigTypeDeserializerState::AddData(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<VarListConfigTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(VarListConfigTypeDeserializerState::Documentation(None));
                    *self.state = VarListConfigTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = VarListConfigTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VarListConfigTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = VarListConfigTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = VarListConfigTypeDeserializerState::Documentation(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::VarListConfigType> for Box<VarListConfigTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::VarListConfigType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    VarListConfigTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::VarListConfigType>
            where
                R: DeserializeReader,
            {
                use VarListConfigTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::ConfigVariable(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_config_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = VarListConfigTypeDeserializerState::ConfigVariable(None);
                            event
                        }
                        (S::ConfigVariable(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"configVariable",
                                true,
                            )?;
                            match self.handle_config_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::VarListConfigType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    VarListConfigTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::VarListConfigType {
                    config_variable: self.config_variable,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct VarListPlainTypeDeserializer {
            variable: Vec<super::VarListPlainVariableElementType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<VarListPlainTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum VarListPlainTypeDeserializerState {
            Init__,
            Variable(
                Option<<super::VarListPlainVariableElementType as WithDeserializer>::Deserializer>,
            ),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl VarListPlainTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    variable: Vec::new(),
                    add_data: None,
                    documentation: None,
                    state: Box::new(VarListPlainTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: VarListPlainTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use VarListPlainTypeDeserializerState as S;
                match state {
                    S::Variable(Some(deserializer)) => {
                        self.store_variable(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_variable(
                &mut self,
                value: super::VarListPlainVariableElementType,
            ) -> Result<(), Error> {
                self.variable.push(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_variable<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::VarListPlainVariableElementType>,
                fallback: &mut Option<VarListPlainTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(VarListPlainTypeDeserializerState::Variable(None));
                    *self.state = VarListPlainTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_variable(data)?;
                        *self.state = VarListPlainTypeDeserializerState::Variable(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VarListPlainTypeDeserializerState::Variable(Some(deserializer)),
                                );
                                *self.state = VarListPlainTypeDeserializerState::Variable(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    VarListPlainTypeDeserializerState::Variable(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<VarListPlainTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(VarListPlainTypeDeserializerState::AddData(None));
                    *self.state = VarListPlainTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = VarListPlainTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(VarListPlainTypeDeserializerState::AddData(
                                    Some(deserializer),
                                ));
                                *self.state =
                                    VarListPlainTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    VarListPlainTypeDeserializerState::AddData(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<VarListPlainTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(VarListPlainTypeDeserializerState::Documentation(None));
                    *self.state = VarListPlainTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = VarListPlainTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VarListPlainTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = VarListPlainTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = VarListPlainTypeDeserializerState::Documentation(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::VarListPlainType> for Box<VarListPlainTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::VarListPlainType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    VarListPlainTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::VarListPlainType>
            where
                R: DeserializeReader,
            {
                use VarListPlainTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Variable(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = VarListPlainTypeDeserializerState::Variable(None);
                            event
                        }
                        (S::Variable(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"variable",
                                true,
                            )?;
                            match self.handle_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::VarListPlainType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    VarListPlainTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::VarListPlainType {
                    variable: self.variable,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct AddDataDataElementTypeDeserializer {
            name: ::std::string::String,
            handle_unknown: super::AddDataDataHandleUnknownType,
            any: Option<AnyElement>,
            state: Box<AddDataDataElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum AddDataDataElementTypeDeserializerState {
            Init__,
            Any(Option<<AnyElement as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl AddDataDataElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                let mut handle_unknown: Option<super::AddDataDataHandleUnknownType> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"handleUnknown")
                    ) {
                        reader.read_attrib(&mut handle_unknown, b"handleUnknown", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    name: name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("name".into()))
                    })?,
                    handle_unknown: handle_unknown.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("handleUnknown".into()))
                    })?,
                    any: None,
                    state: Box::new(AddDataDataElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: AddDataDataElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use AddDataDataElementTypeDeserializerState as S;
                match state {
                    S::Any(Some(deserializer)) => self.store_any(deserializer.finish(reader)?)?,
                    _ => (),
                }
                Ok(())
            }
            fn store_any(&mut self, value: AnyElement) -> Result<(), Error> {
                if self.any.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"any37",
                    )))?;
                }
                self.any = Some(value);
                Ok(())
            }
            fn handle_any<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, AnyElement>,
                fallback: &mut Option<AddDataDataElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.any.is_some() {
                        fallback.get_or_insert(AddDataDataElementTypeDeserializerState::Any(None));
                        *self.state = AddDataDataElementTypeDeserializerState::Done__;
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = AddDataDataElementTypeDeserializerState::Any(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_any(data)?;
                        *self.state = AddDataDataElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    AddDataDataElementTypeDeserializerState::Any(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = AddDataDataElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = AddDataDataElementTypeDeserializerState::Any(Some(
                                    deserializer,
                                ));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::AddDataDataElementType>
            for Box<AddDataDataElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::AddDataDataElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    AddDataDataElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::AddDataDataElementType>
            where
                R: DeserializeReader,
            {
                use AddDataDataElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let mut is_any_retry = false;
                let mut any_fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Any(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_any(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = AddDataDataElementTypeDeserializerState::Any(None);
                            event
                        }
                        (S::Any(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            if is_any_retry {
                                let output = <AnyElement as WithDeserializer>::Deserializer::init(
                                    reader, event,
                                )?;
                                match self.handle_any(reader, output, &mut fallback)? {
                                    ElementHandlerOutput::Continue { event, allow_any } => {
                                        allow_any_element = allow_any_element || allow_any;
                                        event
                                    }
                                    ElementHandlerOutput::Break { event, allow_any } => {
                                        break (event, allow_any)
                                    }
                                }
                            } else {
                                any_fallback.get_or_insert(S::Any(None));
                                *self.state = S::Done__;
                                event
                            }
                        }
                        (S::Done__, event) => {
                            if let Some(state) = any_fallback.take() {
                                is_any_retry = true;
                                *self.state = state;
                                event
                            } else {
                                fallback.get_or_insert(S::Done__);
                                break (DeserializerEvent::Continue(event), allow_any_element);
                            }
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::AddDataDataElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    AddDataDataElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::AddDataDataElementType {
                    name: self.name,
                    handle_unknown: self.handle_unknown,
                    any: self
                        .any
                        .ok_or_else(|| ErrorKind::MissingElement("any37".into()))?,
                })
            }
        }
        #[derive(Debug)]
        pub struct AddDataInfoInfoElementTypeDeserializer {
            name: ::std::string::String,
            version: Option<::core::primitive::f64>,
            vendor: ::std::string::String,
            description: Option<super::FormattedTextType>,
            state: Box<AddDataInfoInfoElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum AddDataInfoInfoElementTypeDeserializerState {
            Init__,
            Description(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl AddDataInfoInfoElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                let mut version: Option<::core::primitive::f64> = None;
                let mut vendor: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"version")
                    ) {
                        reader.read_attrib(&mut version, b"version", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"vendor")
                    ) {
                        reader.read_attrib(&mut vendor, b"vendor", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    name: name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("name".into()))
                    })?,
                    version: version,
                    vendor: vendor.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("vendor".into()))
                    })?,
                    description: None,
                    state: Box::new(AddDataInfoInfoElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: AddDataInfoInfoElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use AddDataInfoInfoElementTypeDeserializerState as S;
                match state {
                    S::Description(Some(deserializer)) => {
                        self.store_description(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_description(&mut self, value: super::FormattedTextType) -> Result<(), Error> {
                if self.description.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"description",
                    )))?;
                }
                self.description = Some(value);
                Ok(())
            }
            fn handle_description<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<AddDataInfoInfoElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        AddDataInfoInfoElementTypeDeserializerState::Description(None),
                    );
                    *self.state = AddDataInfoInfoElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_description(data)?;
                        *self.state = AddDataInfoInfoElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    AddDataInfoInfoElementTypeDeserializerState::Description(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = AddDataInfoInfoElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    AddDataInfoInfoElementTypeDeserializerState::Description(Some(
                                        deserializer,
                                    ));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::AddDataInfoInfoElementType>
            for Box<AddDataInfoInfoElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::AddDataInfoInfoElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    AddDataInfoInfoElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::AddDataInfoInfoElementType>
            where
                R: DeserializeReader,
            {
                use AddDataInfoInfoElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Description(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_description(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                AddDataInfoInfoElementTypeDeserializerState::Description(None);
                            event
                        }
                        (S::Description(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"description",
                                true,
                            )?;
                            match self.handle_description(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::AddDataInfoInfoElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    AddDataInfoInfoElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::AddDataInfoInfoElementType {
                    name: self.name,
                    version: self.version,
                    vendor: self.vendor,
                    description: self.description,
                })
            }
        }
        #[derive(Debug)]
        pub struct BodyFbdElementTypeDeserializer {
            content: Vec<super::BodyFbdElementTypeContent>,
            state: Box<BodyFbdElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum BodyFbdElementTypeDeserializerState {
            Init__,
            Next__,
            Content__(<super::BodyFbdElementTypeContent as WithDeserializer>::Deserializer),
            Unknown__,
        }
        impl BodyFbdElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    content: Vec::new(),
                    state: Box::new(BodyFbdElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: BodyFbdElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                if let BodyFbdElementTypeDeserializerState::Content__(deserializer) = state {
                    self.store_content(deserializer.finish(reader)?)?;
                }
                Ok(())
            }
            fn store_content(
                &mut self,
                value: super::BodyFbdElementTypeContent,
            ) -> Result<(), Error> {
                self.content.push(value);
                Ok(())
            }
            fn handle_content<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::BodyFbdElementTypeContent>,
                fallback: &mut Option<BodyFbdElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = fallback
                        .take()
                        .unwrap_or(BodyFbdElementTypeDeserializerState::Next__);
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_content(data)?;
                        *self.state = BodyFbdElementTypeDeserializerState::Next__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    BodyFbdElementTypeDeserializerState::Content__(deserializer);
                            }
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    BodyFbdElementTypeDeserializerState::Content__(deserializer),
                                );
                                *self.state = BodyFbdElementTypeDeserializerState::Next__;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::BodyFbdElementType> for Box<BodyFbdElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BodyFbdElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    BodyFbdElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BodyFbdElementType>
            where
                R: DeserializeReader,
            {
                use BodyFbdElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Content__(deserializer), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (_, Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (state @ (S::Init__ | S::Next__), event) => {
                            fallback.get_or_insert(state);
                            let output = < super :: BodyFbdElementTypeContent as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = DeserializerArtifact::Deserializer(self);
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::BodyFbdElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    BodyFbdElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::BodyFbdElementType {
                    content: self.content,
                })
            }
        }
        #[derive(Debug)]
        pub struct BodyFbdElementTypeContentDeserializer {
            state: Box<BodyFbdElementTypeContentDeserializerState>,
        }
        #[derive(Debug)]
        pub enum BodyFbdElementTypeContentDeserializerState {
            Init__,
            Comment(
                Option<super::CommentElementType>,
                Option<<super::CommentElementType as WithDeserializer>::Deserializer>,
            ),
            Error(
                Option<super::CommentElementType>,
                Option<<super::CommentElementType as WithDeserializer>::Deserializer>,
            ),
            Connector(
                Option<super::ConnectorElementType>,
                Option<<super::ConnectorElementType as WithDeserializer>::Deserializer>,
            ),
            Continuation(
                Option<super::ContinuationElementType>,
                Option<<super::ContinuationElementType as WithDeserializer>::Deserializer>,
            ),
            ActionBlock(
                Option<super::ActionBlockElementType>,
                Option<<super::ActionBlockElementType as WithDeserializer>::Deserializer>,
            ),
            VendorElement(
                Option<super::VendorElementElementType>,
                Option<<super::VendorElementElementType as WithDeserializer>::Deserializer>,
            ),
            Block(
                Option<super::BlockElementType>,
                Option<<super::BlockElementType as WithDeserializer>::Deserializer>,
            ),
            InVariable(
                Option<super::InVariableElementType>,
                Option<<super::InVariableElementType as WithDeserializer>::Deserializer>,
            ),
            OutVariable(
                Option<super::OutVariableElementType>,
                Option<<super::OutVariableElementType as WithDeserializer>::Deserializer>,
            ),
            InOutVariable(
                Option<super::InOutVariableElementType>,
                Option<<super::InOutVariableElementType as WithDeserializer>::Deserializer>,
            ),
            Label(
                Option<super::LabelElementType>,
                Option<<super::LabelElementType as WithDeserializer>::Deserializer>,
            ),
            Jump(
                Option<super::JumpElementType>,
                Option<<super::JumpElementType as WithDeserializer>::Deserializer>,
            ),
            Return(
                Option<super::ReturnElementType>,
                Option<<super::ReturnElementType as WithDeserializer>::Deserializer>,
            ),
            Done__(super::BodyFbdElementTypeContent),
            Unknown__,
        }
        impl BodyFbdElementTypeContentDeserializer {
            fn find_suitable<'de, R>(
                &mut self,
                reader: &R,
                event: Event<'de>,
                fallback: &mut Option<BodyFbdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                if let Event::Start(x) | Event::Empty(x) = &event {
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"comment")
                    ) {
                        let output =
                            <super::CommentElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_comment(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"error")
                    ) {
                        let output =
                            <super::CommentElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_error(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"connector")
                    ) {
                        let output =
                            <super::ConnectorElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_connector(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"continuation")
                    ) {
                        let output = < super :: ContinuationElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_continuation(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"actionBlock")
                    ) {
                        let output = < super :: ActionBlockElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_action_block(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"vendorElement")
                    ) {
                        let output = < super :: VendorElementElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_vendor_element(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"block")
                    ) {
                        let output =
                            <super::BlockElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_block(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"inVariable")
                    ) {
                        let output =
                            <super::InVariableElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_in_variable(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"outVariable")
                    ) {
                        let output = < super :: OutVariableElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_out_variable(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"inOutVariable")
                    ) {
                        let output = < super :: InOutVariableElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_in_out_variable(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"label")
                    ) {
                        let output =
                            <super::LabelElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_label(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"jump")
                    ) {
                        let output =
                            <super::JumpElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_jump(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"return")
                    ) {
                        let output =
                            <super::ReturnElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_return(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                }
                *self.state = fallback
                    .take()
                    .unwrap_or(BodyFbdElementTypeContentDeserializerState::Init__);
                Ok(ElementHandlerOutput::return_to_parent(event, false))
            }
            fn finish_state<R>(
                reader: &R,
                state: BodyFbdElementTypeContentDeserializerState,
            ) -> Result<super::BodyFbdElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                use BodyFbdElementTypeContentDeserializerState as S;
                match state {
                    S::Init__ => Err(ErrorKind::MissingContent.into()),
                    S::Comment(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyFbdElementTypeContentDeserializer::store_comment(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyFbdElementTypeContent::Comment(
                            values.ok_or_else(|| ErrorKind::MissingElement("comment".into()))?,
                        ))
                    }
                    S::Error(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyFbdElementTypeContentDeserializer::store_error(&mut values, value)?;
                        }
                        Ok(super::BodyFbdElementTypeContent::Error(values.ok_or_else(
                            || ErrorKind::MissingElement("error".into()),
                        )?))
                    }
                    S::Connector(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyFbdElementTypeContentDeserializer::store_connector(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyFbdElementTypeContent::Connector(
                            values.ok_or_else(|| ErrorKind::MissingElement("connector".into()))?,
                        ))
                    }
                    S::Continuation(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyFbdElementTypeContentDeserializer::store_continuation(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyFbdElementTypeContent::Continuation(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("continuation".into()))?,
                        ))
                    }
                    S::ActionBlock(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyFbdElementTypeContentDeserializer::store_action_block(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyFbdElementTypeContent::ActionBlock(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("actionBlock".into()))?,
                        ))
                    }
                    S::VendorElement(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyFbdElementTypeContentDeserializer::store_vendor_element(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyFbdElementTypeContent::VendorElement(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("vendorElement".into()))?,
                        ))
                    }
                    S::Block(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyFbdElementTypeContentDeserializer::store_block(&mut values, value)?;
                        }
                        Ok(super::BodyFbdElementTypeContent::Block(values.ok_or_else(
                            || ErrorKind::MissingElement("block".into()),
                        )?))
                    }
                    S::InVariable(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyFbdElementTypeContentDeserializer::store_in_variable(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyFbdElementTypeContent::InVariable(
                            values.ok_or_else(|| ErrorKind::MissingElement("inVariable".into()))?,
                        ))
                    }
                    S::OutVariable(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyFbdElementTypeContentDeserializer::store_out_variable(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyFbdElementTypeContent::OutVariable(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("outVariable".into()))?,
                        ))
                    }
                    S::InOutVariable(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyFbdElementTypeContentDeserializer::store_in_out_variable(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyFbdElementTypeContent::InOutVariable(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("inOutVariable".into()))?,
                        ))
                    }
                    S::Label(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyFbdElementTypeContentDeserializer::store_label(&mut values, value)?;
                        }
                        Ok(super::BodyFbdElementTypeContent::Label(values.ok_or_else(
                            || ErrorKind::MissingElement("label".into()),
                        )?))
                    }
                    S::Jump(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyFbdElementTypeContentDeserializer::store_jump(&mut values, value)?;
                        }
                        Ok(super::BodyFbdElementTypeContent::Jump(
                            values.ok_or_else(|| ErrorKind::MissingElement("jump".into()))?,
                        ))
                    }
                    S::Return(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyFbdElementTypeContentDeserializer::store_return(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyFbdElementTypeContent::Return(
                            values.ok_or_else(|| ErrorKind::MissingElement("return".into()))?,
                        ))
                    }
                    S::Done__(data) => Ok(data),
                    S::Unknown__ => unreachable!(),
                }
            }
            fn store_comment(
                values: &mut Option<super::CommentElementType>,
                value: super::CommentElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"comment",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_error(
                values: &mut Option<super::CommentElementType>,
                value: super::CommentElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"error",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_connector(
                values: &mut Option<super::ConnectorElementType>,
                value: super::ConnectorElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connector",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_continuation(
                values: &mut Option<super::ContinuationElementType>,
                value: super::ContinuationElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"continuation",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_action_block(
                values: &mut Option<super::ActionBlockElementType>,
                value: super::ActionBlockElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"actionBlock",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_vendor_element(
                values: &mut Option<super::VendorElementElementType>,
                value: super::VendorElementElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"vendorElement",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_block(
                values: &mut Option<super::BlockElementType>,
                value: super::BlockElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"block",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_in_variable(
                values: &mut Option<super::InVariableElementType>,
                value: super::InVariableElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"inVariable",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_out_variable(
                values: &mut Option<super::OutVariableElementType>,
                value: super::OutVariableElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"outVariable",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_in_out_variable(
                values: &mut Option<super::InOutVariableElementType>,
                value: super::InOutVariableElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"inOutVariable",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_label(
                values: &mut Option<super::LabelElementType>,
                value: super::LabelElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"label",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_jump(
                values: &mut Option<super::JumpElementType>,
                value: super::JumpElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"jump")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_return(
                values: &mut Option<super::ReturnElementType>,
                value: super::ReturnElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"return",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn handle_comment<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::CommentElementType>,
                output: DeserializerOutput<'de, super::CommentElementType>,
                fallback: &mut Option<BodyFbdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyFbdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyFbdElementTypeContentDeserializerState::Comment(values, None),
                        Some(BodyFbdElementTypeContentDeserializerState::Comment(
                            _,
                            Some(deserializer),
                        )) => BodyFbdElementTypeContentDeserializerState::Comment(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyFbdElementTypeContentDeserializerState::Comment(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyFbdElementTypeContentDeserializer::store_comment(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyFbdElementTypeContentDeserializer::store_comment(&mut values, data)?;
                        let data = BodyFbdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyFbdElementTypeContentDeserializerState::Comment(values, None),
                        )?;
                        *self.state = BodyFbdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyFbdElementTypeContentDeserializerState::Comment(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_error<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::CommentElementType>,
                output: DeserializerOutput<'de, super::CommentElementType>,
                fallback: &mut Option<BodyFbdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyFbdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyFbdElementTypeContentDeserializerState::Error(values, None),
                        Some(BodyFbdElementTypeContentDeserializerState::Error(
                            _,
                            Some(deserializer),
                        )) => BodyFbdElementTypeContentDeserializerState::Error(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyFbdElementTypeContentDeserializerState::Error(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyFbdElementTypeContentDeserializer::store_error(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyFbdElementTypeContentDeserializer::store_error(&mut values, data)?;
                        let data = BodyFbdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyFbdElementTypeContentDeserializerState::Error(values, None),
                        )?;
                        *self.state = BodyFbdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyFbdElementTypeContentDeserializerState::Error(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_connector<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ConnectorElementType>,
                output: DeserializerOutput<'de, super::ConnectorElementType>,
                fallback: &mut Option<BodyFbdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyFbdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyFbdElementTypeContentDeserializerState::Connector(values, None),
                        Some(BodyFbdElementTypeContentDeserializerState::Connector(
                            _,
                            Some(deserializer),
                        )) => BodyFbdElementTypeContentDeserializerState::Connector(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyFbdElementTypeContentDeserializerState::Connector(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyFbdElementTypeContentDeserializer::store_connector(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyFbdElementTypeContentDeserializer::store_connector(&mut values, data)?;
                        let data = BodyFbdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyFbdElementTypeContentDeserializerState::Connector(values, None),
                        )?;
                        *self.state = BodyFbdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyFbdElementTypeContentDeserializerState::Connector(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_continuation<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ContinuationElementType>,
                output: DeserializerOutput<'de, super::ContinuationElementType>,
                fallback: &mut Option<BodyFbdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyFbdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodyFbdElementTypeContentDeserializerState::Continuation(values, None)
                        }
                        Some(BodyFbdElementTypeContentDeserializerState::Continuation(
                            _,
                            Some(deserializer),
                        )) => BodyFbdElementTypeContentDeserializerState::Continuation(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyFbdElementTypeContentDeserializerState::Continuation(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyFbdElementTypeContentDeserializer::store_continuation(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyFbdElementTypeContentDeserializer::store_continuation(
                            &mut values,
                            data,
                        )?;
                        let data = BodyFbdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyFbdElementTypeContentDeserializerState::Continuation(values, None),
                        )?;
                        *self.state = BodyFbdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyFbdElementTypeContentDeserializerState::Continuation(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_action_block<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ActionBlockElementType>,
                output: DeserializerOutput<'de, super::ActionBlockElementType>,
                fallback: &mut Option<BodyFbdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyFbdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodyFbdElementTypeContentDeserializerState::ActionBlock(values, None)
                        }
                        Some(BodyFbdElementTypeContentDeserializerState::ActionBlock(
                            _,
                            Some(deserializer),
                        )) => BodyFbdElementTypeContentDeserializerState::ActionBlock(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyFbdElementTypeContentDeserializerState::ActionBlock(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyFbdElementTypeContentDeserializer::store_action_block(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyFbdElementTypeContentDeserializer::store_action_block(
                            &mut values,
                            data,
                        )?;
                        let data = BodyFbdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyFbdElementTypeContentDeserializerState::ActionBlock(values, None),
                        )?;
                        *self.state = BodyFbdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyFbdElementTypeContentDeserializerState::ActionBlock(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_vendor_element<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::VendorElementElementType>,
                output: DeserializerOutput<'de, super::VendorElementElementType>,
                fallback: &mut Option<BodyFbdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyFbdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodyFbdElementTypeContentDeserializerState::VendorElement(values, None)
                        }
                        Some(BodyFbdElementTypeContentDeserializerState::VendorElement(
                            _,
                            Some(deserializer),
                        )) => BodyFbdElementTypeContentDeserializerState::VendorElement(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyFbdElementTypeContentDeserializerState::VendorElement(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyFbdElementTypeContentDeserializer::store_vendor_element(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyFbdElementTypeContentDeserializer::store_vendor_element(
                            &mut values,
                            data,
                        )?;
                        let data = BodyFbdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyFbdElementTypeContentDeserializerState::VendorElement(values, None),
                        )?;
                        *self.state = BodyFbdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyFbdElementTypeContentDeserializerState::VendorElement(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_block<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::BlockElementType>,
                output: DeserializerOutput<'de, super::BlockElementType>,
                fallback: &mut Option<BodyFbdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyFbdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyFbdElementTypeContentDeserializerState::Block(values, None),
                        Some(BodyFbdElementTypeContentDeserializerState::Block(
                            _,
                            Some(deserializer),
                        )) => BodyFbdElementTypeContentDeserializerState::Block(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyFbdElementTypeContentDeserializerState::Block(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyFbdElementTypeContentDeserializer::store_block(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyFbdElementTypeContentDeserializer::store_block(&mut values, data)?;
                        let data = BodyFbdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyFbdElementTypeContentDeserializerState::Block(values, None),
                        )?;
                        *self.state = BodyFbdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyFbdElementTypeContentDeserializerState::Block(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_in_variable<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::InVariableElementType>,
                output: DeserializerOutput<'de, super::InVariableElementType>,
                fallback: &mut Option<BodyFbdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyFbdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodyFbdElementTypeContentDeserializerState::InVariable(values, None)
                        }
                        Some(BodyFbdElementTypeContentDeserializerState::InVariable(
                            _,
                            Some(deserializer),
                        )) => BodyFbdElementTypeContentDeserializerState::InVariable(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyFbdElementTypeContentDeserializerState::InVariable(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyFbdElementTypeContentDeserializer::store_in_variable(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyFbdElementTypeContentDeserializer::store_in_variable(
                            &mut values,
                            data,
                        )?;
                        let data = BodyFbdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyFbdElementTypeContentDeserializerState::InVariable(values, None),
                        )?;
                        *self.state = BodyFbdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyFbdElementTypeContentDeserializerState::InVariable(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_out_variable<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::OutVariableElementType>,
                output: DeserializerOutput<'de, super::OutVariableElementType>,
                fallback: &mut Option<BodyFbdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyFbdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodyFbdElementTypeContentDeserializerState::OutVariable(values, None)
                        }
                        Some(BodyFbdElementTypeContentDeserializerState::OutVariable(
                            _,
                            Some(deserializer),
                        )) => BodyFbdElementTypeContentDeserializerState::OutVariable(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyFbdElementTypeContentDeserializerState::OutVariable(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyFbdElementTypeContentDeserializer::store_out_variable(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyFbdElementTypeContentDeserializer::store_out_variable(
                            &mut values,
                            data,
                        )?;
                        let data = BodyFbdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyFbdElementTypeContentDeserializerState::OutVariable(values, None),
                        )?;
                        *self.state = BodyFbdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyFbdElementTypeContentDeserializerState::OutVariable(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_in_out_variable<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::InOutVariableElementType>,
                output: DeserializerOutput<'de, super::InOutVariableElementType>,
                fallback: &mut Option<BodyFbdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyFbdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodyFbdElementTypeContentDeserializerState::InOutVariable(values, None)
                        }
                        Some(BodyFbdElementTypeContentDeserializerState::InOutVariable(
                            _,
                            Some(deserializer),
                        )) => BodyFbdElementTypeContentDeserializerState::InOutVariable(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyFbdElementTypeContentDeserializerState::InOutVariable(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyFbdElementTypeContentDeserializer::store_in_out_variable(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyFbdElementTypeContentDeserializer::store_in_out_variable(
                            &mut values,
                            data,
                        )?;
                        let data = BodyFbdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyFbdElementTypeContentDeserializerState::InOutVariable(values, None),
                        )?;
                        *self.state = BodyFbdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyFbdElementTypeContentDeserializerState::InOutVariable(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_label<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::LabelElementType>,
                output: DeserializerOutput<'de, super::LabelElementType>,
                fallback: &mut Option<BodyFbdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyFbdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyFbdElementTypeContentDeserializerState::Label(values, None),
                        Some(BodyFbdElementTypeContentDeserializerState::Label(
                            _,
                            Some(deserializer),
                        )) => BodyFbdElementTypeContentDeserializerState::Label(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyFbdElementTypeContentDeserializerState::Label(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyFbdElementTypeContentDeserializer::store_label(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyFbdElementTypeContentDeserializer::store_label(&mut values, data)?;
                        let data = BodyFbdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyFbdElementTypeContentDeserializerState::Label(values, None),
                        )?;
                        *self.state = BodyFbdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyFbdElementTypeContentDeserializerState::Label(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_jump<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::JumpElementType>,
                output: DeserializerOutput<'de, super::JumpElementType>,
                fallback: &mut Option<BodyFbdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyFbdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyFbdElementTypeContentDeserializerState::Jump(values, None),
                        Some(BodyFbdElementTypeContentDeserializerState::Jump(
                            _,
                            Some(deserializer),
                        )) => BodyFbdElementTypeContentDeserializerState::Jump(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyFbdElementTypeContentDeserializerState::Jump(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyFbdElementTypeContentDeserializer::store_jump(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyFbdElementTypeContentDeserializer::store_jump(&mut values, data)?;
                        let data = BodyFbdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyFbdElementTypeContentDeserializerState::Jump(values, None),
                        )?;
                        *self.state = BodyFbdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyFbdElementTypeContentDeserializerState::Jump(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_return<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ReturnElementType>,
                output: DeserializerOutput<'de, super::ReturnElementType>,
                fallback: &mut Option<BodyFbdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyFbdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyFbdElementTypeContentDeserializerState::Return(values, None),
                        Some(BodyFbdElementTypeContentDeserializerState::Return(
                            _,
                            Some(deserializer),
                        )) => BodyFbdElementTypeContentDeserializerState::Return(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyFbdElementTypeContentDeserializerState::Return(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyFbdElementTypeContentDeserializer::store_return(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyFbdElementTypeContentDeserializer::store_return(&mut values, data)?;
                        let data = BodyFbdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyFbdElementTypeContentDeserializerState::Return(values, None),
                        )?;
                        *self.state = BodyFbdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyFbdElementTypeContentDeserializerState::Return(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::BodyFbdElementTypeContent>
            for Box<BodyFbdElementTypeContentDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BodyFbdElementTypeContent>
            where
                R: DeserializeReader,
            {
                let deserializer = Box::new(BodyFbdElementTypeContentDeserializer {
                    state: Box::new(BodyFbdElementTypeContentDeserializerState::Init__),
                });
                let mut output = deserializer.next(reader, event)?;
                output.artifact = match output.artifact {
                    DeserializerArtifact::Deserializer(x)
                        if matches!(
                            &*x.state,
                            BodyFbdElementTypeContentDeserializerState::Init__
                        ) =>
                    {
                        DeserializerArtifact::None
                    }
                    artifact => artifact,
                };
                Ok(output)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BodyFbdElementTypeContent>
            where
                R: DeserializeReader,
            {
                use BodyFbdElementTypeContentDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Comment(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_comment(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Error(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_error(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Connector(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connector(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Continuation(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_continuation(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::ActionBlock(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_action_block(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::VendorElement(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_vendor_element(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Block(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_block(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::InVariable(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_in_variable(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::OutVariable(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_out_variable(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::InOutVariable(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_in_out_variable(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Label(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_label(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Jump(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_jump(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Return(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_return(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (state, event @ Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(
                                    BodyFbdElementTypeContentDeserializer::finish_state(
                                        reader, state,
                                    )?,
                                ),
                                event: DeserializerEvent::Continue(event),
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            match self.find_suitable(reader, event, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Comment(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"comment",
                                false,
                            )?;
                            match self.handle_comment(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Error(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"error",
                                false,
                            )?;
                            match self.handle_error(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Connector(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connector",
                                false,
                            )?;
                            match self.handle_connector(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Continuation(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"continuation",
                                false,
                            )?;
                            match self.handle_continuation(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::ActionBlock(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"actionBlock",
                                false,
                            )?;
                            match self.handle_action_block(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::VendorElement(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"vendorElement",
                                false,
                            )?;
                            match self.handle_vendor_element(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Block(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"block",
                                false,
                            )?;
                            match self.handle_block(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::InVariable(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"inVariable",
                                false,
                            )?;
                            match self.handle_in_variable(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::OutVariable(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"outVariable",
                                false,
                            )?;
                            match self.handle_out_variable(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::InOutVariable(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"inOutVariable",
                                false,
                            )?;
                            match self.handle_in_out_variable(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Label(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"label",
                                false,
                            )?;
                            match self.handle_label(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Jump(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"jump",
                                false,
                            )?;
                            match self.handle_jump(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Return(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"return",
                                false,
                            )?;
                            match self.handle_return(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (s @ S::Done__(_), event) => {
                            *self.state = s;
                            break (DeserializerEvent::Continue(event), false);
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = if matches!(&*self.state, S::Done__(_)) {
                    DeserializerArtifact::Data(self.finish(reader)?)
                } else {
                    DeserializerArtifact::Deserializer(self)
                };
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(self, reader: &R) -> Result<super::BodyFbdElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                BodyFbdElementTypeContentDeserializer::finish_state(reader, *self.state)
            }
        }
        #[derive(Debug)]
        pub struct BodyLdElementTypeDeserializer {
            content: Vec<super::BodyLdElementTypeContent>,
            state: Box<BodyLdElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum BodyLdElementTypeDeserializerState {
            Init__,
            Next__,
            Content__(<super::BodyLdElementTypeContent as WithDeserializer>::Deserializer),
            Unknown__,
        }
        impl BodyLdElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    content: Vec::new(),
                    state: Box::new(BodyLdElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: BodyLdElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                if let BodyLdElementTypeDeserializerState::Content__(deserializer) = state {
                    self.store_content(deserializer.finish(reader)?)?;
                }
                Ok(())
            }
            fn store_content(
                &mut self,
                value: super::BodyLdElementTypeContent,
            ) -> Result<(), Error> {
                self.content.push(value);
                Ok(())
            }
            fn handle_content<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::BodyLdElementTypeContent>,
                fallback: &mut Option<BodyLdElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = fallback
                        .take()
                        .unwrap_or(BodyLdElementTypeDeserializerState::Next__);
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_content(data)?;
                        *self.state = BodyLdElementTypeDeserializerState::Next__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    BodyLdElementTypeDeserializerState::Content__(deserializer);
                            }
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    BodyLdElementTypeDeserializerState::Content__(deserializer),
                                );
                                *self.state = BodyLdElementTypeDeserializerState::Next__;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::BodyLdElementType> for Box<BodyLdElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BodyLdElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    BodyLdElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BodyLdElementType>
            where
                R: DeserializeReader,
            {
                use BodyLdElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Content__(deserializer), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (_, Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (state @ (S::Init__ | S::Next__), event) => {
                            fallback.get_or_insert(state);
                            let output = < super :: BodyLdElementTypeContent as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = DeserializerArtifact::Deserializer(self);
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::BodyLdElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    BodyLdElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::BodyLdElementType {
                    content: self.content,
                })
            }
        }
        #[derive(Debug)]
        pub struct BodyLdElementTypeContentDeserializer {
            state: Box<BodyLdElementTypeContentDeserializerState>,
        }
        #[derive(Debug)]
        pub enum BodyLdElementTypeContentDeserializerState {
            Init__,
            Comment(
                Option<super::CommentElementType>,
                Option<<super::CommentElementType as WithDeserializer>::Deserializer>,
            ),
            Error(
                Option<super::CommentElementType>,
                Option<<super::CommentElementType as WithDeserializer>::Deserializer>,
            ),
            Connector(
                Option<super::ConnectorElementType>,
                Option<<super::ConnectorElementType as WithDeserializer>::Deserializer>,
            ),
            Continuation(
                Option<super::ContinuationElementType>,
                Option<<super::ContinuationElementType as WithDeserializer>::Deserializer>,
            ),
            ActionBlock(
                Option<super::ActionBlockElementType>,
                Option<<super::ActionBlockElementType as WithDeserializer>::Deserializer>,
            ),
            VendorElement(
                Option<super::VendorElementElementType>,
                Option<<super::VendorElementElementType as WithDeserializer>::Deserializer>,
            ),
            Block(
                Option<super::BlockElementType>,
                Option<<super::BlockElementType as WithDeserializer>::Deserializer>,
            ),
            InVariable(
                Option<super::InVariableElementType>,
                Option<<super::InVariableElementType as WithDeserializer>::Deserializer>,
            ),
            OutVariable(
                Option<super::OutVariableElementType>,
                Option<<super::OutVariableElementType as WithDeserializer>::Deserializer>,
            ),
            InOutVariable(
                Option<super::InOutVariableElementType>,
                Option<<super::InOutVariableElementType as WithDeserializer>::Deserializer>,
            ),
            Label(
                Option<super::LabelElementType>,
                Option<<super::LabelElementType as WithDeserializer>::Deserializer>,
            ),
            Jump(
                Option<super::JumpElementType>,
                Option<<super::JumpElementType as WithDeserializer>::Deserializer>,
            ),
            Return(
                Option<super::ReturnElementType>,
                Option<<super::ReturnElementType as WithDeserializer>::Deserializer>,
            ),
            LeftPowerRail(
                Option<super::LeftPowerRailElementType>,
                Option<<super::LeftPowerRailElementType as WithDeserializer>::Deserializer>,
            ),
            RightPowerRail(
                Option<super::RightPowerRailElementType>,
                Option<<super::RightPowerRailElementType as WithDeserializer>::Deserializer>,
            ),
            Coil(
                Option<super::CoilElementType>,
                Option<<super::CoilElementType as WithDeserializer>::Deserializer>,
            ),
            Contact(
                Option<super::CoilElementType>,
                Option<<super::CoilElementType as WithDeserializer>::Deserializer>,
            ),
            Done__(super::BodyLdElementTypeContent),
            Unknown__,
        }
        impl BodyLdElementTypeContentDeserializer {
            fn find_suitable<'de, R>(
                &mut self,
                reader: &R,
                event: Event<'de>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                if let Event::Start(x) | Event::Empty(x) = &event {
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"comment")
                    ) {
                        let output =
                            <super::CommentElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_comment(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"error")
                    ) {
                        let output =
                            <super::CommentElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_error(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"connector")
                    ) {
                        let output =
                            <super::ConnectorElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_connector(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"continuation")
                    ) {
                        let output = < super :: ContinuationElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_continuation(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"actionBlock")
                    ) {
                        let output = < super :: ActionBlockElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_action_block(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"vendorElement")
                    ) {
                        let output = < super :: VendorElementElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_vendor_element(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"block")
                    ) {
                        let output =
                            <super::BlockElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_block(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"inVariable")
                    ) {
                        let output =
                            <super::InVariableElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_in_variable(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"outVariable")
                    ) {
                        let output = < super :: OutVariableElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_out_variable(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"inOutVariable")
                    ) {
                        let output = < super :: InOutVariableElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_in_out_variable(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"label")
                    ) {
                        let output =
                            <super::LabelElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_label(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"jump")
                    ) {
                        let output =
                            <super::JumpElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_jump(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"return")
                    ) {
                        let output =
                            <super::ReturnElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_return(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"leftPowerRail")
                    ) {
                        let output = < super :: LeftPowerRailElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_left_power_rail(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"rightPowerRail")
                    ) {
                        let output = < super :: RightPowerRailElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_right_power_rail(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"coil")
                    ) {
                        let output =
                            <super::CoilElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_coil(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"contact")
                    ) {
                        let output =
                            <super::CoilElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_contact(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                }
                *self.state = fallback
                    .take()
                    .unwrap_or(BodyLdElementTypeContentDeserializerState::Init__);
                Ok(ElementHandlerOutput::return_to_parent(event, false))
            }
            fn finish_state<R>(
                reader: &R,
                state: BodyLdElementTypeContentDeserializerState,
            ) -> Result<super::BodyLdElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                use BodyLdElementTypeContentDeserializerState as S;
                match state {
                    S::Init__ => Err(ErrorKind::MissingContent.into()),
                    S::Comment(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyLdElementTypeContentDeserializer::store_comment(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyLdElementTypeContent::Comment(
                            values.ok_or_else(|| ErrorKind::MissingElement("comment".into()))?,
                        ))
                    }
                    S::Error(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyLdElementTypeContentDeserializer::store_error(&mut values, value)?;
                        }
                        Ok(super::BodyLdElementTypeContent::Error(values.ok_or_else(
                            || ErrorKind::MissingElement("error".into()),
                        )?))
                    }
                    S::Connector(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyLdElementTypeContentDeserializer::store_connector(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyLdElementTypeContent::Connector(
                            values.ok_or_else(|| ErrorKind::MissingElement("connector".into()))?,
                        ))
                    }
                    S::Continuation(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyLdElementTypeContentDeserializer::store_continuation(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyLdElementTypeContent::Continuation(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("continuation".into()))?,
                        ))
                    }
                    S::ActionBlock(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyLdElementTypeContentDeserializer::store_action_block(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyLdElementTypeContent::ActionBlock(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("actionBlock".into()))?,
                        ))
                    }
                    S::VendorElement(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyLdElementTypeContentDeserializer::store_vendor_element(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyLdElementTypeContent::VendorElement(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("vendorElement".into()))?,
                        ))
                    }
                    S::Block(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyLdElementTypeContentDeserializer::store_block(&mut values, value)?;
                        }
                        Ok(super::BodyLdElementTypeContent::Block(values.ok_or_else(
                            || ErrorKind::MissingElement("block".into()),
                        )?))
                    }
                    S::InVariable(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyLdElementTypeContentDeserializer::store_in_variable(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyLdElementTypeContent::InVariable(
                            values.ok_or_else(|| ErrorKind::MissingElement("inVariable".into()))?,
                        ))
                    }
                    S::OutVariable(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyLdElementTypeContentDeserializer::store_out_variable(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyLdElementTypeContent::OutVariable(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("outVariable".into()))?,
                        ))
                    }
                    S::InOutVariable(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyLdElementTypeContentDeserializer::store_in_out_variable(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyLdElementTypeContent::InOutVariable(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("inOutVariable".into()))?,
                        ))
                    }
                    S::Label(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyLdElementTypeContentDeserializer::store_label(&mut values, value)?;
                        }
                        Ok(super::BodyLdElementTypeContent::Label(values.ok_or_else(
                            || ErrorKind::MissingElement("label".into()),
                        )?))
                    }
                    S::Jump(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyLdElementTypeContentDeserializer::store_jump(&mut values, value)?;
                        }
                        Ok(super::BodyLdElementTypeContent::Jump(
                            values.ok_or_else(|| ErrorKind::MissingElement("jump".into()))?,
                        ))
                    }
                    S::Return(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyLdElementTypeContentDeserializer::store_return(&mut values, value)?;
                        }
                        Ok(super::BodyLdElementTypeContent::Return(values.ok_or_else(
                            || ErrorKind::MissingElement("return".into()),
                        )?))
                    }
                    S::LeftPowerRail(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyLdElementTypeContentDeserializer::store_left_power_rail(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyLdElementTypeContent::LeftPowerRail(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("leftPowerRail".into()))?,
                        ))
                    }
                    S::RightPowerRail(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyLdElementTypeContentDeserializer::store_right_power_rail(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyLdElementTypeContent::RightPowerRail(
                            values.ok_or_else(|| {
                                ErrorKind::MissingElement("rightPowerRail".into())
                            })?,
                        ))
                    }
                    S::Coil(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyLdElementTypeContentDeserializer::store_coil(&mut values, value)?;
                        }
                        Ok(super::BodyLdElementTypeContent::Coil(
                            values.ok_or_else(|| ErrorKind::MissingElement("coil".into()))?,
                        ))
                    }
                    S::Contact(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodyLdElementTypeContentDeserializer::store_contact(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodyLdElementTypeContent::Contact(
                            values.ok_or_else(|| ErrorKind::MissingElement("contact".into()))?,
                        ))
                    }
                    S::Done__(data) => Ok(data),
                    S::Unknown__ => unreachable!(),
                }
            }
            fn store_comment(
                values: &mut Option<super::CommentElementType>,
                value: super::CommentElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"comment",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_error(
                values: &mut Option<super::CommentElementType>,
                value: super::CommentElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"error",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_connector(
                values: &mut Option<super::ConnectorElementType>,
                value: super::ConnectorElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connector",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_continuation(
                values: &mut Option<super::ContinuationElementType>,
                value: super::ContinuationElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"continuation",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_action_block(
                values: &mut Option<super::ActionBlockElementType>,
                value: super::ActionBlockElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"actionBlock",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_vendor_element(
                values: &mut Option<super::VendorElementElementType>,
                value: super::VendorElementElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"vendorElement",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_block(
                values: &mut Option<super::BlockElementType>,
                value: super::BlockElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"block",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_in_variable(
                values: &mut Option<super::InVariableElementType>,
                value: super::InVariableElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"inVariable",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_out_variable(
                values: &mut Option<super::OutVariableElementType>,
                value: super::OutVariableElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"outVariable",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_in_out_variable(
                values: &mut Option<super::InOutVariableElementType>,
                value: super::InOutVariableElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"inOutVariable",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_label(
                values: &mut Option<super::LabelElementType>,
                value: super::LabelElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"label",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_jump(
                values: &mut Option<super::JumpElementType>,
                value: super::JumpElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"jump")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_return(
                values: &mut Option<super::ReturnElementType>,
                value: super::ReturnElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"return",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_left_power_rail(
                values: &mut Option<super::LeftPowerRailElementType>,
                value: super::LeftPowerRailElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"leftPowerRail",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_right_power_rail(
                values: &mut Option<super::RightPowerRailElementType>,
                value: super::RightPowerRailElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"rightPowerRail",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_coil(
                values: &mut Option<super::CoilElementType>,
                value: super::CoilElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"coil")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_contact(
                values: &mut Option<super::CoilElementType>,
                value: super::CoilElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"contact",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn handle_comment<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::CommentElementType>,
                output: DeserializerOutput<'de, super::CommentElementType>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyLdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyLdElementTypeContentDeserializerState::Comment(values, None),
                        Some(BodyLdElementTypeContentDeserializerState::Comment(
                            _,
                            Some(deserializer),
                        )) => BodyLdElementTypeContentDeserializerState::Comment(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyLdElementTypeContentDeserializerState::Comment(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyLdElementTypeContentDeserializer::store_comment(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyLdElementTypeContentDeserializer::store_comment(&mut values, data)?;
                        let data = BodyLdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyLdElementTypeContentDeserializerState::Comment(values, None),
                        )?;
                        *self.state = BodyLdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyLdElementTypeContentDeserializerState::Comment(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_error<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::CommentElementType>,
                output: DeserializerOutput<'de, super::CommentElementType>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyLdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyLdElementTypeContentDeserializerState::Error(values, None),
                        Some(BodyLdElementTypeContentDeserializerState::Error(
                            _,
                            Some(deserializer),
                        )) => BodyLdElementTypeContentDeserializerState::Error(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyLdElementTypeContentDeserializerState::Error(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyLdElementTypeContentDeserializer::store_error(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyLdElementTypeContentDeserializer::store_error(&mut values, data)?;
                        let data = BodyLdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyLdElementTypeContentDeserializerState::Error(values, None),
                        )?;
                        *self.state = BodyLdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyLdElementTypeContentDeserializerState::Error(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_connector<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ConnectorElementType>,
                output: DeserializerOutput<'de, super::ConnectorElementType>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyLdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyLdElementTypeContentDeserializerState::Connector(values, None),
                        Some(BodyLdElementTypeContentDeserializerState::Connector(
                            _,
                            Some(deserializer),
                        )) => BodyLdElementTypeContentDeserializerState::Connector(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyLdElementTypeContentDeserializerState::Connector(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyLdElementTypeContentDeserializer::store_connector(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyLdElementTypeContentDeserializer::store_connector(&mut values, data)?;
                        let data = BodyLdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyLdElementTypeContentDeserializerState::Connector(values, None),
                        )?;
                        *self.state = BodyLdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyLdElementTypeContentDeserializerState::Connector(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_continuation<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ContinuationElementType>,
                output: DeserializerOutput<'de, super::ContinuationElementType>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyLdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodyLdElementTypeContentDeserializerState::Continuation(values, None)
                        }
                        Some(BodyLdElementTypeContentDeserializerState::Continuation(
                            _,
                            Some(deserializer),
                        )) => BodyLdElementTypeContentDeserializerState::Continuation(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyLdElementTypeContentDeserializerState::Continuation(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyLdElementTypeContentDeserializer::store_continuation(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyLdElementTypeContentDeserializer::store_continuation(
                            &mut values,
                            data,
                        )?;
                        let data = BodyLdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyLdElementTypeContentDeserializerState::Continuation(values, None),
                        )?;
                        *self.state = BodyLdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyLdElementTypeContentDeserializerState::Continuation(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_action_block<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ActionBlockElementType>,
                output: DeserializerOutput<'de, super::ActionBlockElementType>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyLdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodyLdElementTypeContentDeserializerState::ActionBlock(values, None)
                        }
                        Some(BodyLdElementTypeContentDeserializerState::ActionBlock(
                            _,
                            Some(deserializer),
                        )) => BodyLdElementTypeContentDeserializerState::ActionBlock(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyLdElementTypeContentDeserializerState::ActionBlock(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyLdElementTypeContentDeserializer::store_action_block(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyLdElementTypeContentDeserializer::store_action_block(
                            &mut values,
                            data,
                        )?;
                        let data = BodyLdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyLdElementTypeContentDeserializerState::ActionBlock(values, None),
                        )?;
                        *self.state = BodyLdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyLdElementTypeContentDeserializerState::ActionBlock(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_vendor_element<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::VendorElementElementType>,
                output: DeserializerOutput<'de, super::VendorElementElementType>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyLdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodyLdElementTypeContentDeserializerState::VendorElement(values, None)
                        }
                        Some(BodyLdElementTypeContentDeserializerState::VendorElement(
                            _,
                            Some(deserializer),
                        )) => BodyLdElementTypeContentDeserializerState::VendorElement(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyLdElementTypeContentDeserializerState::VendorElement(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyLdElementTypeContentDeserializer::store_vendor_element(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyLdElementTypeContentDeserializer::store_vendor_element(
                            &mut values,
                            data,
                        )?;
                        let data = BodyLdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyLdElementTypeContentDeserializerState::VendorElement(values, None),
                        )?;
                        *self.state = BodyLdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyLdElementTypeContentDeserializerState::VendorElement(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_block<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::BlockElementType>,
                output: DeserializerOutput<'de, super::BlockElementType>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyLdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyLdElementTypeContentDeserializerState::Block(values, None),
                        Some(BodyLdElementTypeContentDeserializerState::Block(
                            _,
                            Some(deserializer),
                        )) => BodyLdElementTypeContentDeserializerState::Block(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyLdElementTypeContentDeserializerState::Block(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyLdElementTypeContentDeserializer::store_block(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyLdElementTypeContentDeserializer::store_block(&mut values, data)?;
                        let data = BodyLdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyLdElementTypeContentDeserializerState::Block(values, None),
                        )?;
                        *self.state = BodyLdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyLdElementTypeContentDeserializerState::Block(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_in_variable<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::InVariableElementType>,
                output: DeserializerOutput<'de, super::InVariableElementType>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyLdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyLdElementTypeContentDeserializerState::InVariable(values, None),
                        Some(BodyLdElementTypeContentDeserializerState::InVariable(
                            _,
                            Some(deserializer),
                        )) => BodyLdElementTypeContentDeserializerState::InVariable(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyLdElementTypeContentDeserializerState::InVariable(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyLdElementTypeContentDeserializer::store_in_variable(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyLdElementTypeContentDeserializer::store_in_variable(&mut values, data)?;
                        let data = BodyLdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyLdElementTypeContentDeserializerState::InVariable(values, None),
                        )?;
                        *self.state = BodyLdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyLdElementTypeContentDeserializerState::InVariable(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_out_variable<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::OutVariableElementType>,
                output: DeserializerOutput<'de, super::OutVariableElementType>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyLdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodyLdElementTypeContentDeserializerState::OutVariable(values, None)
                        }
                        Some(BodyLdElementTypeContentDeserializerState::OutVariable(
                            _,
                            Some(deserializer),
                        )) => BodyLdElementTypeContentDeserializerState::OutVariable(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyLdElementTypeContentDeserializerState::OutVariable(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyLdElementTypeContentDeserializer::store_out_variable(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyLdElementTypeContentDeserializer::store_out_variable(
                            &mut values,
                            data,
                        )?;
                        let data = BodyLdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyLdElementTypeContentDeserializerState::OutVariable(values, None),
                        )?;
                        *self.state = BodyLdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyLdElementTypeContentDeserializerState::OutVariable(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_in_out_variable<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::InOutVariableElementType>,
                output: DeserializerOutput<'de, super::InOutVariableElementType>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyLdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodyLdElementTypeContentDeserializerState::InOutVariable(values, None)
                        }
                        Some(BodyLdElementTypeContentDeserializerState::InOutVariable(
                            _,
                            Some(deserializer),
                        )) => BodyLdElementTypeContentDeserializerState::InOutVariable(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyLdElementTypeContentDeserializerState::InOutVariable(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyLdElementTypeContentDeserializer::store_in_out_variable(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyLdElementTypeContentDeserializer::store_in_out_variable(
                            &mut values,
                            data,
                        )?;
                        let data = BodyLdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyLdElementTypeContentDeserializerState::InOutVariable(values, None),
                        )?;
                        *self.state = BodyLdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyLdElementTypeContentDeserializerState::InOutVariable(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_label<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::LabelElementType>,
                output: DeserializerOutput<'de, super::LabelElementType>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyLdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyLdElementTypeContentDeserializerState::Label(values, None),
                        Some(BodyLdElementTypeContentDeserializerState::Label(
                            _,
                            Some(deserializer),
                        )) => BodyLdElementTypeContentDeserializerState::Label(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyLdElementTypeContentDeserializerState::Label(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyLdElementTypeContentDeserializer::store_label(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyLdElementTypeContentDeserializer::store_label(&mut values, data)?;
                        let data = BodyLdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyLdElementTypeContentDeserializerState::Label(values, None),
                        )?;
                        *self.state = BodyLdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyLdElementTypeContentDeserializerState::Label(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_jump<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::JumpElementType>,
                output: DeserializerOutput<'de, super::JumpElementType>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyLdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyLdElementTypeContentDeserializerState::Jump(values, None),
                        Some(BodyLdElementTypeContentDeserializerState::Jump(
                            _,
                            Some(deserializer),
                        )) => BodyLdElementTypeContentDeserializerState::Jump(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyLdElementTypeContentDeserializerState::Jump(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyLdElementTypeContentDeserializer::store_jump(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyLdElementTypeContentDeserializer::store_jump(&mut values, data)?;
                        let data = BodyLdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyLdElementTypeContentDeserializerState::Jump(values, None),
                        )?;
                        *self.state = BodyLdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyLdElementTypeContentDeserializerState::Jump(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_return<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ReturnElementType>,
                output: DeserializerOutput<'de, super::ReturnElementType>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyLdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyLdElementTypeContentDeserializerState::Return(values, None),
                        Some(BodyLdElementTypeContentDeserializerState::Return(
                            _,
                            Some(deserializer),
                        )) => BodyLdElementTypeContentDeserializerState::Return(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyLdElementTypeContentDeserializerState::Return(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyLdElementTypeContentDeserializer::store_return(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyLdElementTypeContentDeserializer::store_return(&mut values, data)?;
                        let data = BodyLdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyLdElementTypeContentDeserializerState::Return(values, None),
                        )?;
                        *self.state = BodyLdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyLdElementTypeContentDeserializerState::Return(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_left_power_rail<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::LeftPowerRailElementType>,
                output: DeserializerOutput<'de, super::LeftPowerRailElementType>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyLdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodyLdElementTypeContentDeserializerState::LeftPowerRail(values, None)
                        }
                        Some(BodyLdElementTypeContentDeserializerState::LeftPowerRail(
                            _,
                            Some(deserializer),
                        )) => BodyLdElementTypeContentDeserializerState::LeftPowerRail(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyLdElementTypeContentDeserializerState::LeftPowerRail(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyLdElementTypeContentDeserializer::store_left_power_rail(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyLdElementTypeContentDeserializer::store_left_power_rail(
                            &mut values,
                            data,
                        )?;
                        let data = BodyLdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyLdElementTypeContentDeserializerState::LeftPowerRail(values, None),
                        )?;
                        *self.state = BodyLdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyLdElementTypeContentDeserializerState::LeftPowerRail(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_right_power_rail<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::RightPowerRailElementType>,
                output: DeserializerOutput<'de, super::RightPowerRailElementType>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyLdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodyLdElementTypeContentDeserializerState::RightPowerRail(values, None)
                        }
                        Some(BodyLdElementTypeContentDeserializerState::RightPowerRail(
                            _,
                            Some(deserializer),
                        )) => BodyLdElementTypeContentDeserializerState::RightPowerRail(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyLdElementTypeContentDeserializerState::RightPowerRail(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyLdElementTypeContentDeserializer::store_right_power_rail(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyLdElementTypeContentDeserializer::store_right_power_rail(
                            &mut values,
                            data,
                        )?;
                        let data = BodyLdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyLdElementTypeContentDeserializerState::RightPowerRail(values, None),
                        )?;
                        *self.state = BodyLdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyLdElementTypeContentDeserializerState::RightPowerRail(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_coil<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::CoilElementType>,
                output: DeserializerOutput<'de, super::CoilElementType>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyLdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyLdElementTypeContentDeserializerState::Coil(values, None),
                        Some(BodyLdElementTypeContentDeserializerState::Coil(
                            _,
                            Some(deserializer),
                        )) => BodyLdElementTypeContentDeserializerState::Coil(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyLdElementTypeContentDeserializerState::Coil(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyLdElementTypeContentDeserializer::store_coil(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyLdElementTypeContentDeserializer::store_coil(&mut values, data)?;
                        let data = BodyLdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyLdElementTypeContentDeserializerState::Coil(values, None),
                        )?;
                        *self.state = BodyLdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyLdElementTypeContentDeserializerState::Coil(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_contact<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::CoilElementType>,
                output: DeserializerOutput<'de, super::CoilElementType>,
                fallback: &mut Option<BodyLdElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodyLdElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodyLdElementTypeContentDeserializerState::Contact(values, None),
                        Some(BodyLdElementTypeContentDeserializerState::Contact(
                            _,
                            Some(deserializer),
                        )) => BodyLdElementTypeContentDeserializerState::Contact(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodyLdElementTypeContentDeserializerState::Contact(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodyLdElementTypeContentDeserializer::store_contact(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodyLdElementTypeContentDeserializer::store_contact(&mut values, data)?;
                        let data = BodyLdElementTypeContentDeserializer::finish_state(
                            reader,
                            BodyLdElementTypeContentDeserializerState::Contact(values, None),
                        )?;
                        *self.state = BodyLdElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodyLdElementTypeContentDeserializerState::Contact(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::BodyLdElementTypeContent>
            for Box<BodyLdElementTypeContentDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BodyLdElementTypeContent>
            where
                R: DeserializeReader,
            {
                let deserializer = Box::new(BodyLdElementTypeContentDeserializer {
                    state: Box::new(BodyLdElementTypeContentDeserializerState::Init__),
                });
                let mut output = deserializer.next(reader, event)?;
                output.artifact = match output.artifact {
                    DeserializerArtifact::Deserializer(x)
                        if matches!(
                            &*x.state,
                            BodyLdElementTypeContentDeserializerState::Init__
                        ) =>
                    {
                        DeserializerArtifact::None
                    }
                    artifact => artifact,
                };
                Ok(output)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BodyLdElementTypeContent>
            where
                R: DeserializeReader,
            {
                use BodyLdElementTypeContentDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Comment(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_comment(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Error(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_error(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Connector(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connector(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Continuation(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_continuation(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::ActionBlock(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_action_block(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::VendorElement(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_vendor_element(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Block(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_block(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::InVariable(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_in_variable(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::OutVariable(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_out_variable(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::InOutVariable(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_in_out_variable(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Label(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_label(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Jump(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_jump(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Return(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_return(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::LeftPowerRail(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_left_power_rail(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::RightPowerRail(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_right_power_rail(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Coil(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_coil(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Contact(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_contact(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (state, event @ Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(
                                    BodyLdElementTypeContentDeserializer::finish_state(
                                        reader, state,
                                    )?,
                                ),
                                event: DeserializerEvent::Continue(event),
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            match self.find_suitable(reader, event, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Comment(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"comment",
                                false,
                            )?;
                            match self.handle_comment(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Error(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"error",
                                false,
                            )?;
                            match self.handle_error(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Connector(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connector",
                                false,
                            )?;
                            match self.handle_connector(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Continuation(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"continuation",
                                false,
                            )?;
                            match self.handle_continuation(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::ActionBlock(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"actionBlock",
                                false,
                            )?;
                            match self.handle_action_block(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::VendorElement(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"vendorElement",
                                false,
                            )?;
                            match self.handle_vendor_element(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Block(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"block",
                                false,
                            )?;
                            match self.handle_block(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::InVariable(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"inVariable",
                                false,
                            )?;
                            match self.handle_in_variable(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::OutVariable(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"outVariable",
                                false,
                            )?;
                            match self.handle_out_variable(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::InOutVariable(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"inOutVariable",
                                false,
                            )?;
                            match self.handle_in_out_variable(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Label(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"label",
                                false,
                            )?;
                            match self.handle_label(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Jump(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"jump",
                                false,
                            )?;
                            match self.handle_jump(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Return(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"return",
                                false,
                            )?;
                            match self.handle_return(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::LeftPowerRail(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"leftPowerRail",
                                false,
                            )?;
                            match self.handle_left_power_rail(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::RightPowerRail(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"rightPowerRail",
                                false,
                            )?;
                            match self.handle_right_power_rail(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Coil(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"coil",
                                false,
                            )?;
                            match self.handle_coil(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Contact(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"contact",
                                false,
                            )?;
                            match self.handle_contact(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (s @ S::Done__(_), event) => {
                            *self.state = s;
                            break (DeserializerEvent::Continue(event), false);
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = if matches!(&*self.state, S::Done__(_)) {
                    DeserializerArtifact::Data(self.finish(reader)?)
                } else {
                    DeserializerArtifact::Deserializer(self)
                };
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(self, reader: &R) -> Result<super::BodyLdElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                BodyLdElementTypeContentDeserializer::finish_state(reader, *self.state)
            }
        }
        #[derive(Debug)]
        pub struct BodySfcElementTypeDeserializer {
            content: Vec<super::BodySfcElementTypeContent>,
            state: Box<BodySfcElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum BodySfcElementTypeDeserializerState {
            Init__,
            Next__,
            Content__(<super::BodySfcElementTypeContent as WithDeserializer>::Deserializer),
            Unknown__,
        }
        impl BodySfcElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    content: Vec::new(),
                    state: Box::new(BodySfcElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: BodySfcElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                if let BodySfcElementTypeDeserializerState::Content__(deserializer) = state {
                    self.store_content(deserializer.finish(reader)?)?;
                }
                Ok(())
            }
            fn store_content(
                &mut self,
                value: super::BodySfcElementTypeContent,
            ) -> Result<(), Error> {
                self.content.push(value);
                Ok(())
            }
            fn handle_content<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::BodySfcElementTypeContent>,
                fallback: &mut Option<BodySfcElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = fallback
                        .take()
                        .unwrap_or(BodySfcElementTypeDeserializerState::Next__);
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_content(data)?;
                        *self.state = BodySfcElementTypeDeserializerState::Next__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    BodySfcElementTypeDeserializerState::Content__(deserializer);
                            }
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    BodySfcElementTypeDeserializerState::Content__(deserializer),
                                );
                                *self.state = BodySfcElementTypeDeserializerState::Next__;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::BodySfcElementType> for Box<BodySfcElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BodySfcElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    BodySfcElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BodySfcElementType>
            where
                R: DeserializeReader,
            {
                use BodySfcElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Content__(deserializer), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (_, Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (state @ (S::Init__ | S::Next__), event) => {
                            fallback.get_or_insert(state);
                            let output = < super :: BodySfcElementTypeContent as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = DeserializerArtifact::Deserializer(self);
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::BodySfcElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    BodySfcElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::BodySfcElementType {
                    content: self.content,
                })
            }
        }
        #[derive(Debug)]
        pub struct BodySfcElementTypeContentDeserializer {
            state: Box<BodySfcElementTypeContentDeserializerState>,
        }
        #[derive(Debug)]
        pub enum BodySfcElementTypeContentDeserializerState {
            Init__,
            Comment(
                Option<super::CommentElementType>,
                Option<<super::CommentElementType as WithDeserializer>::Deserializer>,
            ),
            Error(
                Option<super::CommentElementType>,
                Option<<super::CommentElementType as WithDeserializer>::Deserializer>,
            ),
            Connector(
                Option<super::ConnectorElementType>,
                Option<<super::ConnectorElementType as WithDeserializer>::Deserializer>,
            ),
            Continuation(
                Option<super::ContinuationElementType>,
                Option<<super::ContinuationElementType as WithDeserializer>::Deserializer>,
            ),
            ActionBlock(
                Option<super::ActionBlockElementType>,
                Option<<super::ActionBlockElementType as WithDeserializer>::Deserializer>,
            ),
            VendorElement(
                Option<super::VendorElementElementType>,
                Option<<super::VendorElementElementType as WithDeserializer>::Deserializer>,
            ),
            Block(
                Option<super::BlockElementType>,
                Option<<super::BlockElementType as WithDeserializer>::Deserializer>,
            ),
            InVariable(
                Option<super::InVariableElementType>,
                Option<<super::InVariableElementType as WithDeserializer>::Deserializer>,
            ),
            OutVariable(
                Option<super::OutVariableElementType>,
                Option<<super::OutVariableElementType as WithDeserializer>::Deserializer>,
            ),
            InOutVariable(
                Option<super::InOutVariableElementType>,
                Option<<super::InOutVariableElementType as WithDeserializer>::Deserializer>,
            ),
            Label(
                Option<super::LabelElementType>,
                Option<<super::LabelElementType as WithDeserializer>::Deserializer>,
            ),
            Jump(
                Option<super::JumpElementType>,
                Option<<super::JumpElementType as WithDeserializer>::Deserializer>,
            ),
            Return(
                Option<super::ReturnElementType>,
                Option<<super::ReturnElementType as WithDeserializer>::Deserializer>,
            ),
            LeftPowerRail(
                Option<super::LeftPowerRailElementType>,
                Option<<super::LeftPowerRailElementType as WithDeserializer>::Deserializer>,
            ),
            RightPowerRail(
                Option<super::RightPowerRailElementType>,
                Option<<super::RightPowerRailElementType as WithDeserializer>::Deserializer>,
            ),
            Coil(
                Option<super::CoilElementType>,
                Option<<super::CoilElementType as WithDeserializer>::Deserializer>,
            ),
            Contact(
                Option<super::CoilElementType>,
                Option<<super::CoilElementType as WithDeserializer>::Deserializer>,
            ),
            Step(
                Option<super::StepElementType>,
                Option<<super::StepElementType as WithDeserializer>::Deserializer>,
            ),
            MacroStep(
                Option<super::MacroStepElementType>,
                Option<<super::MacroStepElementType as WithDeserializer>::Deserializer>,
            ),
            JumpStep(
                Option<super::JumpStepElementType>,
                Option<<super::JumpStepElementType as WithDeserializer>::Deserializer>,
            ),
            Transition(
                Option<super::TransitionElementType>,
                Option<<super::TransitionElementType as WithDeserializer>::Deserializer>,
            ),
            SelectionDivergence(
                Option<super::SelectionDivergenceElementType>,
                Option<<super::SelectionDivergenceElementType as WithDeserializer>::Deserializer>,
            ),
            SelectionConvergence(
                Option<super::SelectionConvergenceElementType>,
                Option<<super::SelectionConvergenceElementType as WithDeserializer>::Deserializer>,
            ),
            SimultaneousDivergence(
                Option<super::SimultaneousDivergenceElementType>,
                Option<
                    <super::SimultaneousDivergenceElementType as WithDeserializer>::Deserializer,
                >,
            ),
            SimultaneousConvergence(
                Option<super::SimultaneousConvergenceElementType>,
                Option<
                    <super::SimultaneousConvergenceElementType as WithDeserializer>::Deserializer,
                >,
            ),
            Done__(super::BodySfcElementTypeContent),
            Unknown__,
        }
        impl BodySfcElementTypeContentDeserializer {
            fn find_suitable<'de, R>(
                &mut self,
                reader: &R,
                event: Event<'de>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                if let Event::Start(x) | Event::Empty(x) = &event {
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"comment")
                    ) {
                        let output =
                            <super::CommentElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_comment(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"error")
                    ) {
                        let output =
                            <super::CommentElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_error(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"connector")
                    ) {
                        let output =
                            <super::ConnectorElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_connector(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"continuation")
                    ) {
                        let output = < super :: ContinuationElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_continuation(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"actionBlock")
                    ) {
                        let output = < super :: ActionBlockElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_action_block(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"vendorElement")
                    ) {
                        let output = < super :: VendorElementElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_vendor_element(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"block")
                    ) {
                        let output =
                            <super::BlockElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_block(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"inVariable")
                    ) {
                        let output =
                            <super::InVariableElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_in_variable(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"outVariable")
                    ) {
                        let output = < super :: OutVariableElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_out_variable(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"inOutVariable")
                    ) {
                        let output = < super :: InOutVariableElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_in_out_variable(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"label")
                    ) {
                        let output =
                            <super::LabelElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_label(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"jump")
                    ) {
                        let output =
                            <super::JumpElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_jump(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"return")
                    ) {
                        let output =
                            <super::ReturnElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_return(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"leftPowerRail")
                    ) {
                        let output = < super :: LeftPowerRailElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_left_power_rail(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"rightPowerRail")
                    ) {
                        let output = < super :: RightPowerRailElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_right_power_rail(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"coil")
                    ) {
                        let output =
                            <super::CoilElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_coil(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"contact")
                    ) {
                        let output =
                            <super::CoilElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_contact(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"step")
                    ) {
                        let output =
                            <super::StepElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_step(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"macroStep")
                    ) {
                        let output =
                            <super::MacroStepElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_macro_step(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"jumpStep")
                    ) {
                        let output =
                            <super::JumpStepElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_jump_step(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"transition")
                    ) {
                        let output =
                            <super::TransitionElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_transition(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"selectionDivergence")
                    ) {
                        let output = < super :: SelectionDivergenceElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_selection_divergence(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"selectionConvergence")
                    ) {
                        let output = < super :: SelectionConvergenceElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_selection_convergence(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"simultaneousDivergence")
                    ) {
                        let output = < super :: SimultaneousDivergenceElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_simultaneous_divergence(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"simultaneousConvergence")
                    ) {
                        let output = < super :: SimultaneousConvergenceElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_simultaneous_convergence(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                }
                *self.state = fallback
                    .take()
                    .unwrap_or(BodySfcElementTypeContentDeserializerState::Init__);
                Ok(ElementHandlerOutput::return_to_parent(event, false))
            }
            fn finish_state<R>(
                reader: &R,
                state: BodySfcElementTypeContentDeserializerState,
            ) -> Result<super::BodySfcElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                use BodySfcElementTypeContentDeserializerState as S;
                match state {
                    S::Init__ => Err(ErrorKind::MissingContent.into()),
                    S::Comment(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_comment(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::Comment(
                            values.ok_or_else(|| ErrorKind::MissingElement("comment".into()))?,
                        ))
                    }
                    S::Error(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_error(&mut values, value)?;
                        }
                        Ok(super::BodySfcElementTypeContent::Error(values.ok_or_else(
                            || ErrorKind::MissingElement("error".into()),
                        )?))
                    }
                    S::Connector(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_connector(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::Connector(
                            values.ok_or_else(|| ErrorKind::MissingElement("connector".into()))?,
                        ))
                    }
                    S::Continuation(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_continuation(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::Continuation(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("continuation".into()))?,
                        ))
                    }
                    S::ActionBlock(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_action_block(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::ActionBlock(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("actionBlock".into()))?,
                        ))
                    }
                    S::VendorElement(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_vendor_element(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::VendorElement(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("vendorElement".into()))?,
                        ))
                    }
                    S::Block(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_block(&mut values, value)?;
                        }
                        Ok(super::BodySfcElementTypeContent::Block(values.ok_or_else(
                            || ErrorKind::MissingElement("block".into()),
                        )?))
                    }
                    S::InVariable(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_in_variable(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::InVariable(
                            values.ok_or_else(|| ErrorKind::MissingElement("inVariable".into()))?,
                        ))
                    }
                    S::OutVariable(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_out_variable(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::OutVariable(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("outVariable".into()))?,
                        ))
                    }
                    S::InOutVariable(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_in_out_variable(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::InOutVariable(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("inOutVariable".into()))?,
                        ))
                    }
                    S::Label(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_label(&mut values, value)?;
                        }
                        Ok(super::BodySfcElementTypeContent::Label(values.ok_or_else(
                            || ErrorKind::MissingElement("label".into()),
                        )?))
                    }
                    S::Jump(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_jump(&mut values, value)?;
                        }
                        Ok(super::BodySfcElementTypeContent::Jump(
                            values.ok_or_else(|| ErrorKind::MissingElement("jump".into()))?,
                        ))
                    }
                    S::Return(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_return(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::Return(
                            values.ok_or_else(|| ErrorKind::MissingElement("return".into()))?,
                        ))
                    }
                    S::LeftPowerRail(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_left_power_rail(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::LeftPowerRail(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("leftPowerRail".into()))?,
                        ))
                    }
                    S::RightPowerRail(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_right_power_rail(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::RightPowerRail(
                            values.ok_or_else(|| {
                                ErrorKind::MissingElement("rightPowerRail".into())
                            })?,
                        ))
                    }
                    S::Coil(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_coil(&mut values, value)?;
                        }
                        Ok(super::BodySfcElementTypeContent::Coil(
                            values.ok_or_else(|| ErrorKind::MissingElement("coil".into()))?,
                        ))
                    }
                    S::Contact(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_contact(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::Contact(
                            values.ok_or_else(|| ErrorKind::MissingElement("contact".into()))?,
                        ))
                    }
                    S::Step(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_step(&mut values, value)?;
                        }
                        Ok(super::BodySfcElementTypeContent::Step(
                            values.ok_or_else(|| ErrorKind::MissingElement("step".into()))?,
                        ))
                    }
                    S::MacroStep(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_macro_step(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::MacroStep(
                            values.ok_or_else(|| ErrorKind::MissingElement("macroStep".into()))?,
                        ))
                    }
                    S::JumpStep(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_jump_step(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::JumpStep(
                            values.ok_or_else(|| ErrorKind::MissingElement("jumpStep".into()))?,
                        ))
                    }
                    S::Transition(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_transition(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::Transition(
                            values.ok_or_else(|| ErrorKind::MissingElement("transition".into()))?,
                        ))
                    }
                    S::SelectionDivergence(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_selection_divergence(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::SelectionDivergence(
                            values.ok_or_else(|| {
                                ErrorKind::MissingElement("selectionDivergence".into())
                            })?,
                        ))
                    }
                    S::SelectionConvergence(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_selection_convergence(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::SelectionConvergence(
                            values.ok_or_else(|| {
                                ErrorKind::MissingElement("selectionConvergence".into())
                            })?,
                        ))
                    }
                    S::SimultaneousDivergence(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_simultaneous_divergence(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::SimultaneousDivergence(
                            values.ok_or_else(|| {
                                ErrorKind::MissingElement("simultaneousDivergence".into())
                            })?,
                        ))
                    }
                    S::SimultaneousConvergence(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            BodySfcElementTypeContentDeserializer::store_simultaneous_convergence(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::BodySfcElementTypeContent::SimultaneousConvergence(
                            values.ok_or_else(|| {
                                ErrorKind::MissingElement("simultaneousConvergence".into())
                            })?,
                        ))
                    }
                    S::Done__(data) => Ok(data),
                    S::Unknown__ => unreachable!(),
                }
            }
            fn store_comment(
                values: &mut Option<super::CommentElementType>,
                value: super::CommentElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"comment",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_error(
                values: &mut Option<super::CommentElementType>,
                value: super::CommentElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"error",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_connector(
                values: &mut Option<super::ConnectorElementType>,
                value: super::ConnectorElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connector",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_continuation(
                values: &mut Option<super::ContinuationElementType>,
                value: super::ContinuationElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"continuation",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_action_block(
                values: &mut Option<super::ActionBlockElementType>,
                value: super::ActionBlockElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"actionBlock",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_vendor_element(
                values: &mut Option<super::VendorElementElementType>,
                value: super::VendorElementElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"vendorElement",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_block(
                values: &mut Option<super::BlockElementType>,
                value: super::BlockElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"block",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_in_variable(
                values: &mut Option<super::InVariableElementType>,
                value: super::InVariableElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"inVariable",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_out_variable(
                values: &mut Option<super::OutVariableElementType>,
                value: super::OutVariableElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"outVariable",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_in_out_variable(
                values: &mut Option<super::InOutVariableElementType>,
                value: super::InOutVariableElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"inOutVariable",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_label(
                values: &mut Option<super::LabelElementType>,
                value: super::LabelElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"label",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_jump(
                values: &mut Option<super::JumpElementType>,
                value: super::JumpElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"jump")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_return(
                values: &mut Option<super::ReturnElementType>,
                value: super::ReturnElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"return",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_left_power_rail(
                values: &mut Option<super::LeftPowerRailElementType>,
                value: super::LeftPowerRailElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"leftPowerRail",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_right_power_rail(
                values: &mut Option<super::RightPowerRailElementType>,
                value: super::RightPowerRailElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"rightPowerRail",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_coil(
                values: &mut Option<super::CoilElementType>,
                value: super::CoilElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"coil")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_contact(
                values: &mut Option<super::CoilElementType>,
                value: super::CoilElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"contact",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_step(
                values: &mut Option<super::StepElementType>,
                value: super::StepElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"step")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_macro_step(
                values: &mut Option<super::MacroStepElementType>,
                value: super::MacroStepElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"macroStep",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_jump_step(
                values: &mut Option<super::JumpStepElementType>,
                value: super::JumpStepElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"jumpStep",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_transition(
                values: &mut Option<super::TransitionElementType>,
                value: super::TransitionElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"transition",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_selection_divergence(
                values: &mut Option<super::SelectionDivergenceElementType>,
                value: super::SelectionDivergenceElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"selectionDivergence",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_selection_convergence(
                values: &mut Option<super::SelectionConvergenceElementType>,
                value: super::SelectionConvergenceElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"selectionConvergence",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_simultaneous_divergence(
                values: &mut Option<super::SimultaneousDivergenceElementType>,
                value: super::SimultaneousDivergenceElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"simultaneousDivergence",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_simultaneous_convergence(
                values: &mut Option<super::SimultaneousConvergenceElementType>,
                value: super::SimultaneousConvergenceElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"simultaneousConvergence",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn handle_comment<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::CommentElementType>,
                output: DeserializerOutput<'de, super::CommentElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodySfcElementTypeContentDeserializerState::Comment(values, None),
                        Some(BodySfcElementTypeContentDeserializerState::Comment(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::Comment(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::Comment(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_comment(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_comment(&mut values, data)?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::Comment(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::Comment(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_error<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::CommentElementType>,
                output: DeserializerOutput<'de, super::CommentElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodySfcElementTypeContentDeserializerState::Error(values, None),
                        Some(BodySfcElementTypeContentDeserializerState::Error(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::Error(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::Error(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_error(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_error(&mut values, data)?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::Error(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::Error(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_connector<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ConnectorElementType>,
                output: DeserializerOutput<'de, super::ConnectorElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodySfcElementTypeContentDeserializerState::Connector(values, None),
                        Some(BodySfcElementTypeContentDeserializerState::Connector(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::Connector(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::Connector(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_connector(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_connector(&mut values, data)?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::Connector(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::Connector(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_continuation<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ContinuationElementType>,
                output: DeserializerOutput<'de, super::ContinuationElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodySfcElementTypeContentDeserializerState::Continuation(values, None)
                        }
                        Some(BodySfcElementTypeContentDeserializerState::Continuation(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::Continuation(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::Continuation(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_continuation(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_continuation(
                            &mut values,
                            data,
                        )?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::Continuation(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::Continuation(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_action_block<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ActionBlockElementType>,
                output: DeserializerOutput<'de, super::ActionBlockElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodySfcElementTypeContentDeserializerState::ActionBlock(values, None)
                        }
                        Some(BodySfcElementTypeContentDeserializerState::ActionBlock(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::ActionBlock(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::ActionBlock(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_action_block(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_action_block(
                            &mut values,
                            data,
                        )?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::ActionBlock(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::ActionBlock(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_vendor_element<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::VendorElementElementType>,
                output: DeserializerOutput<'de, super::VendorElementElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodySfcElementTypeContentDeserializerState::VendorElement(values, None)
                        }
                        Some(BodySfcElementTypeContentDeserializerState::VendorElement(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::VendorElement(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::VendorElement(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_vendor_element(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_vendor_element(
                            &mut values,
                            data,
                        )?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::VendorElement(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::VendorElement(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_block<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::BlockElementType>,
                output: DeserializerOutput<'de, super::BlockElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodySfcElementTypeContentDeserializerState::Block(values, None),
                        Some(BodySfcElementTypeContentDeserializerState::Block(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::Block(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::Block(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_block(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_block(&mut values, data)?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::Block(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::Block(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_in_variable<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::InVariableElementType>,
                output: DeserializerOutput<'de, super::InVariableElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodySfcElementTypeContentDeserializerState::InVariable(values, None)
                        }
                        Some(BodySfcElementTypeContentDeserializerState::InVariable(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::InVariable(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::InVariable(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_in_variable(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_in_variable(
                            &mut values,
                            data,
                        )?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::InVariable(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::InVariable(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_out_variable<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::OutVariableElementType>,
                output: DeserializerOutput<'de, super::OutVariableElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodySfcElementTypeContentDeserializerState::OutVariable(values, None)
                        }
                        Some(BodySfcElementTypeContentDeserializerState::OutVariable(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::OutVariable(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::OutVariable(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_out_variable(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_out_variable(
                            &mut values,
                            data,
                        )?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::OutVariable(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::OutVariable(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_in_out_variable<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::InOutVariableElementType>,
                output: DeserializerOutput<'de, super::InOutVariableElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodySfcElementTypeContentDeserializerState::InOutVariable(values, None)
                        }
                        Some(BodySfcElementTypeContentDeserializerState::InOutVariable(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::InOutVariable(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::InOutVariable(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_in_out_variable(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_in_out_variable(
                            &mut values,
                            data,
                        )?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::InOutVariable(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::InOutVariable(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_label<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::LabelElementType>,
                output: DeserializerOutput<'de, super::LabelElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodySfcElementTypeContentDeserializerState::Label(values, None),
                        Some(BodySfcElementTypeContentDeserializerState::Label(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::Label(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::Label(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_label(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_label(&mut values, data)?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::Label(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::Label(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_jump<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::JumpElementType>,
                output: DeserializerOutput<'de, super::JumpElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodySfcElementTypeContentDeserializerState::Jump(values, None),
                        Some(BodySfcElementTypeContentDeserializerState::Jump(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::Jump(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::Jump(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_jump(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_jump(&mut values, data)?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::Jump(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::Jump(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_return<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ReturnElementType>,
                output: DeserializerOutput<'de, super::ReturnElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodySfcElementTypeContentDeserializerState::Return(values, None),
                        Some(BodySfcElementTypeContentDeserializerState::Return(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::Return(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::Return(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_return(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_return(&mut values, data)?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::Return(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::Return(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_left_power_rail<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::LeftPowerRailElementType>,
                output: DeserializerOutput<'de, super::LeftPowerRailElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodySfcElementTypeContentDeserializerState::LeftPowerRail(values, None)
                        }
                        Some(BodySfcElementTypeContentDeserializerState::LeftPowerRail(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::LeftPowerRail(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::LeftPowerRail(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_left_power_rail(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_left_power_rail(
                            &mut values,
                            data,
                        )?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::LeftPowerRail(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::LeftPowerRail(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_right_power_rail<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::RightPowerRailElementType>,
                output: DeserializerOutput<'de, super::RightPowerRailElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodySfcElementTypeContentDeserializerState::RightPowerRail(values, None)
                        }
                        Some(BodySfcElementTypeContentDeserializerState::RightPowerRail(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::RightPowerRail(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::RightPowerRail(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_right_power_rail(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_right_power_rail(
                            &mut values,
                            data,
                        )?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::RightPowerRail(
                                values, None,
                            ),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::RightPowerRail(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_coil<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::CoilElementType>,
                output: DeserializerOutput<'de, super::CoilElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodySfcElementTypeContentDeserializerState::Coil(values, None),
                        Some(BodySfcElementTypeContentDeserializerState::Coil(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::Coil(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::Coil(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_coil(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_coil(&mut values, data)?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::Coil(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::Coil(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_contact<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::CoilElementType>,
                output: DeserializerOutput<'de, super::CoilElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodySfcElementTypeContentDeserializerState::Contact(values, None),
                        Some(BodySfcElementTypeContentDeserializerState::Contact(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::Contact(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::Contact(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_contact(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_contact(&mut values, data)?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::Contact(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::Contact(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_step<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::StepElementType>,
                output: DeserializerOutput<'de, super::StepElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodySfcElementTypeContentDeserializerState::Step(values, None),
                        Some(BodySfcElementTypeContentDeserializerState::Step(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::Step(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::Step(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_step(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_step(&mut values, data)?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::Step(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::Step(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_macro_step<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::MacroStepElementType>,
                output: DeserializerOutput<'de, super::MacroStepElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodySfcElementTypeContentDeserializerState::MacroStep(values, None),
                        Some(BodySfcElementTypeContentDeserializerState::MacroStep(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::MacroStep(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::MacroStep(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_macro_step(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_macro_step(&mut values, data)?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::MacroStep(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::MacroStep(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_jump_step<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::JumpStepElementType>,
                output: DeserializerOutput<'de, super::JumpStepElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodySfcElementTypeContentDeserializerState::JumpStep(values, None),
                        Some(BodySfcElementTypeContentDeserializerState::JumpStep(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::JumpStep(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::JumpStep(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_jump_step(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_jump_step(&mut values, data)?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::JumpStep(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::JumpStep(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_transition<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::TransitionElementType>,
                output: DeserializerOutput<'de, super::TransitionElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodySfcElementTypeContentDeserializerState::Transition(values, None)
                        }
                        Some(BodySfcElementTypeContentDeserializerState::Transition(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::Transition(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::Transition(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_transition(&mut values, data)?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_transition(&mut values, data)?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::Transition(values, None),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = BodySfcElementTypeContentDeserializerState::Transition(
                            values,
                            Some(deserializer),
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_selection_divergence<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::SelectionDivergenceElementType>,
                output: DeserializerOutput<'de, super::SelectionDivergenceElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodySfcElementTypeContentDeserializerState::SelectionDivergence(
                            values, None,
                        ),
                        Some(BodySfcElementTypeContentDeserializerState::SelectionDivergence(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::SelectionDivergence(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::SelectionDivergence(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_selection_divergence(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_selection_divergence(
                            &mut values,
                            data,
                        )?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::SelectionDivergence(
                                values, None,
                            ),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            BodySfcElementTypeContentDeserializerState::SelectionDivergence(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_selection_convergence<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::SelectionConvergenceElementType>,
                output: DeserializerOutput<'de, super::SelectionConvergenceElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodySfcElementTypeContentDeserializerState::SelectionConvergence(
                            values, None,
                        ),
                        Some(BodySfcElementTypeContentDeserializerState::SelectionConvergence(
                            _,
                            Some(deserializer),
                        )) => BodySfcElementTypeContentDeserializerState::SelectionConvergence(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::SelectionConvergence(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_selection_convergence(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_selection_convergence(
                            &mut values,
                            data,
                        )?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::SelectionConvergence(
                                values, None,
                            ),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            BodySfcElementTypeContentDeserializerState::SelectionConvergence(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_simultaneous_divergence<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::SimultaneousDivergenceElementType>,
                output: DeserializerOutput<'de, super::SimultaneousDivergenceElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => BodySfcElementTypeContentDeserializerState::SimultaneousDivergence(
                            values, None,
                        ),
                        Some(
                            BodySfcElementTypeContentDeserializerState::SimultaneousDivergence(
                                _,
                                Some(deserializer),
                            ),
                        ) => BodySfcElementTypeContentDeserializerState::SimultaneousDivergence(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::SimultaneousDivergence(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_simultaneous_divergence(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_simultaneous_divergence(
                            &mut values,
                            data,
                        )?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::SimultaneousDivergence(
                                values, None,
                            ),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            BodySfcElementTypeContentDeserializerState::SimultaneousDivergence(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_simultaneous_convergence<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::SimultaneousConvergenceElementType>,
                output: DeserializerOutput<'de, super::SimultaneousConvergenceElementType>,
                fallback: &mut Option<BodySfcElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state = BodySfcElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            BodySfcElementTypeContentDeserializerState::SimultaneousConvergence(
                                values, None,
                            )
                        }
                        Some(
                            BodySfcElementTypeContentDeserializerState::SimultaneousConvergence(
                                _,
                                Some(deserializer),
                            ),
                        ) => BodySfcElementTypeContentDeserializerState::SimultaneousConvergence(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(BodySfcElementTypeContentDeserializerState::SimultaneousConvergence(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        BodySfcElementTypeContentDeserializer::store_simultaneous_convergence(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        BodySfcElementTypeContentDeserializer::store_simultaneous_convergence(
                            &mut values,
                            data,
                        )?;
                        let data = BodySfcElementTypeContentDeserializer::finish_state(
                            reader,
                            BodySfcElementTypeContentDeserializerState::SimultaneousConvergence(
                                values, None,
                            ),
                        )?;
                        *self.state = BodySfcElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            BodySfcElementTypeContentDeserializerState::SimultaneousConvergence(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::BodySfcElementTypeContent>
            for Box<BodySfcElementTypeContentDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BodySfcElementTypeContent>
            where
                R: DeserializeReader,
            {
                let deserializer = Box::new(BodySfcElementTypeContentDeserializer {
                    state: Box::new(BodySfcElementTypeContentDeserializerState::Init__),
                });
                let mut output = deserializer.next(reader, event)?;
                output.artifact = match output.artifact {
                    DeserializerArtifact::Deserializer(x)
                        if matches!(
                            &*x.state,
                            BodySfcElementTypeContentDeserializerState::Init__
                        ) =>
                    {
                        DeserializerArtifact::None
                    }
                    artifact => artifact,
                };
                Ok(output)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BodySfcElementTypeContent>
            where
                R: DeserializeReader,
            {
                use BodySfcElementTypeContentDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Comment(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_comment(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Error(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_error(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Connector(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connector(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Continuation(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_continuation(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::ActionBlock(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_action_block(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::VendorElement(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_vendor_element(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Block(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_block(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::InVariable(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_in_variable(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::OutVariable(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_out_variable(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::InOutVariable(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_in_out_variable(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Label(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_label(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Jump(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_jump(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Return(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_return(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::LeftPowerRail(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_left_power_rail(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::RightPowerRail(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_right_power_rail(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Coil(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_coil(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Contact(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_contact(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Step(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_step(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::MacroStep(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_macro_step(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::JumpStep(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_jump_step(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Transition(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_transition(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::SelectionDivergence(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_selection_divergence(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::SelectionConvergence(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_selection_convergence(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::SimultaneousDivergence(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_simultaneous_divergence(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::SimultaneousConvergence(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_simultaneous_convergence(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (state, event @ Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(
                                    BodySfcElementTypeContentDeserializer::finish_state(
                                        reader, state,
                                    )?,
                                ),
                                event: DeserializerEvent::Continue(event),
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            match self.find_suitable(reader, event, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Comment(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"comment",
                                false,
                            )?;
                            match self.handle_comment(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Error(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"error",
                                false,
                            )?;
                            match self.handle_error(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Connector(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connector",
                                false,
                            )?;
                            match self.handle_connector(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Continuation(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"continuation",
                                false,
                            )?;
                            match self.handle_continuation(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::ActionBlock(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"actionBlock",
                                false,
                            )?;
                            match self.handle_action_block(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::VendorElement(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"vendorElement",
                                false,
                            )?;
                            match self.handle_vendor_element(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Block(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"block",
                                false,
                            )?;
                            match self.handle_block(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::InVariable(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"inVariable",
                                false,
                            )?;
                            match self.handle_in_variable(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::OutVariable(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"outVariable",
                                false,
                            )?;
                            match self.handle_out_variable(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::InOutVariable(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"inOutVariable",
                                false,
                            )?;
                            match self.handle_in_out_variable(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Label(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"label",
                                false,
                            )?;
                            match self.handle_label(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Jump(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"jump",
                                false,
                            )?;
                            match self.handle_jump(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Return(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"return",
                                false,
                            )?;
                            match self.handle_return(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::LeftPowerRail(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"leftPowerRail",
                                false,
                            )?;
                            match self.handle_left_power_rail(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::RightPowerRail(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"rightPowerRail",
                                false,
                            )?;
                            match self.handle_right_power_rail(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Coil(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"coil",
                                false,
                            )?;
                            match self.handle_coil(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Contact(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"contact",
                                false,
                            )?;
                            match self.handle_contact(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Step(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"step",
                                false,
                            )?;
                            match self.handle_step(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::MacroStep(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"macroStep",
                                false,
                            )?;
                            match self.handle_macro_step(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::JumpStep(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"jumpStep",
                                false,
                            )?;
                            match self.handle_jump_step(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Transition(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"transition",
                                false,
                            )?;
                            match self.handle_transition(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::SelectionDivergence(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"selectionDivergence",
                                false,
                            )?;
                            match self.handle_selection_divergence(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::SelectionConvergence(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"selectionConvergence",
                                false,
                            )?;
                            match self.handle_selection_convergence(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::SimultaneousDivergence(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"simultaneousDivergence",
                                false,
                            )?;
                            match self.handle_simultaneous_divergence(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::SimultaneousConvergence(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"simultaneousConvergence",
                                false,
                            )?;
                            match self.handle_simultaneous_convergence(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (s @ S::Done__(_), event) => {
                            *self.state = s;
                            break (DeserializerEvent::Continue(event), false);
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = if matches!(&*self.state, S::Done__(_)) {
                    DeserializerArtifact::Data(self.finish(reader)?)
                } else {
                    DeserializerArtifact::Deserializer(self)
                };
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(self, reader: &R) -> Result<super::BodySfcElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                BodySfcElementTypeContentDeserializer::finish_state(reader, *self.state)
            }
        }
        #[derive(Debug)]
        pub struct StringElementTypeDeserializer {
            length: Option<::std::string::String>,
            state: Box<StringElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum StringElementTypeDeserializerState {
            Init__,
            Unknown__,
        }
        impl StringElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut length: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"length")
                    ) {
                        reader.read_attrib(&mut length, b"length", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    length: length,
                    state: Box::new(StringElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: StringElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                Ok(())
            }
        }
        impl<'de> Deserializer<'de, super::StringElementType> for Box<StringElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::StringElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    StringElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::StringElementType>
            where
                R: DeserializeReader,
            {
                if let Event::End(_) = &event {
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(self.finish(reader)?),
                        event: DeserializerEvent::None,
                        allow_any: false,
                    })
                } else {
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event: DeserializerEvent::Break(event),
                        allow_any: false,
                    })
                }
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::StringElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    StringElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::StringElementType {
                    length: self.length,
                })
            }
        }
        #[derive(Debug)]
        pub struct ArrayElementTypeDeserializer {
            dimension: Vec<super::RangeSignedType>,
            base_type: Option<super::DataType>,
            state: Box<ArrayElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ArrayElementTypeDeserializerState {
            Init__,
            Dimension(Option<<super::RangeSignedType as WithDeserializer>::Deserializer>),
            BaseType(Option<<super::DataType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl ArrayElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    dimension: Vec::new(),
                    base_type: None,
                    state: Box::new(ArrayElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ArrayElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ArrayElementTypeDeserializerState as S;
                match state {
                    S::Dimension(Some(deserializer)) => {
                        self.store_dimension(deserializer.finish(reader)?)?
                    }
                    S::BaseType(Some(deserializer)) => {
                        self.store_base_type(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_dimension(&mut self, value: super::RangeSignedType) -> Result<(), Error> {
                self.dimension.push(value);
                Ok(())
            }
            fn store_base_type(&mut self, value: super::DataType) -> Result<(), Error> {
                if self.base_type.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"baseType",
                    )))?;
                }
                self.base_type = Some(value);
                Ok(())
            }
            fn handle_dimension<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::RangeSignedType>,
                fallback: &mut Option<ArrayElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.dimension.len() < 1usize {
                        *self.state = ArrayElementTypeDeserializerState::Dimension(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    } else {
                        fallback.get_or_insert(ArrayElementTypeDeserializerState::Dimension(None));
                        *self.state = ArrayElementTypeDeserializerState::BaseType(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_dimension(data)?;
                        *self.state = ArrayElementTypeDeserializerState::Dimension(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ArrayElementTypeDeserializerState::Dimension(Some(
                                        deserializer,
                                    )),
                                );
                                if self.dimension.len().saturating_add(1) < 1usize {
                                    *self.state =
                                        ArrayElementTypeDeserializerState::Dimension(None);
                                } else {
                                    *self.state = ArrayElementTypeDeserializerState::BaseType(None);
                                }
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ArrayElementTypeDeserializerState::Dimension(Some(
                                    deserializer,
                                ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_base_type<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::DataType>,
                fallback: &mut Option<ArrayElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.base_type.is_some() {
                        fallback.get_or_insert(ArrayElementTypeDeserializerState::BaseType(None));
                        *self.state = ArrayElementTypeDeserializerState::Done__;
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = ArrayElementTypeDeserializerState::BaseType(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_base_type(data)?;
                        *self.state = ArrayElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ArrayElementTypeDeserializerState::BaseType(Some(deserializer)),
                                );
                                *self.state = ArrayElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ArrayElementTypeDeserializerState::BaseType(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ArrayElementType> for Box<ArrayElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ArrayElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ArrayElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ArrayElementType>
            where
                R: DeserializeReader,
            {
                use ArrayElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Dimension(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_dimension(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::BaseType(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_base_type(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = ArrayElementTypeDeserializerState::Dimension(None);
                            event
                        }
                        (S::Dimension(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"dimension",
                                false,
                            )?;
                            match self.handle_dimension(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::BaseType(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"baseType",
                                true,
                            )?;
                            match self.handle_base_type(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::ArrayElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ArrayElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ArrayElementType {
                    dimension: self.dimension,
                    base_type: Box::new(
                        self.base_type
                            .ok_or_else(|| ErrorKind::MissingElement("baseType".into()))?,
                    ),
                })
            }
        }
        #[derive(Debug)]
        pub struct DerivedElementTypeDeserializer {
            name: ::std::string::String,
            add_data: Option<super::AddDataType>,
            state: Box<DerivedElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum DerivedElementTypeDeserializerState {
            Init__,
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl DerivedElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    name: name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("name".into()))
                    })?,
                    add_data: None,
                    state: Box::new(DerivedElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: DerivedElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use DerivedElementTypeDeserializerState as S;
                match state {
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<DerivedElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(DerivedElementTypeDeserializerState::AddData(None));
                    *self.state = DerivedElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = DerivedElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    DerivedElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = DerivedElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = DerivedElementTypeDeserializerState::AddData(Some(
                                    deserializer,
                                ));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::DerivedElementType> for Box<DerivedElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::DerivedElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    DerivedElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::DerivedElementType>
            where
                R: DeserializeReader,
            {
                use DerivedElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = DerivedElementTypeDeserializerState::AddData(None);
                            event
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::DerivedElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    DerivedElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::DerivedElementType {
                    name: self.name,
                    add_data: self.add_data,
                })
            }
        }
        #[derive(Debug)]
        pub struct EnumElementTypeDeserializer {
            values: Option<super::EnumValuesElementType>,
            base_type: Option<super::DataType>,
            state: Box<EnumElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum EnumElementTypeDeserializerState {
            Init__,
            Values(Option<<super::EnumValuesElementType as WithDeserializer>::Deserializer>),
            BaseType(Option<<super::DataType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl EnumElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    values: None,
                    base_type: None,
                    state: Box::new(EnumElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: EnumElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use EnumElementTypeDeserializerState as S;
                match state {
                    S::Values(Some(deserializer)) => {
                        self.store_values(deserializer.finish(reader)?)?
                    }
                    S::BaseType(Some(deserializer)) => {
                        self.store_base_type(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_values(&mut self, value: super::EnumValuesElementType) -> Result<(), Error> {
                if self.values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"values",
                    )))?;
                }
                self.values = Some(value);
                Ok(())
            }
            fn store_base_type(&mut self, value: super::DataType) -> Result<(), Error> {
                if self.base_type.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"baseType",
                    )))?;
                }
                self.base_type = Some(value);
                Ok(())
            }
            fn handle_values<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::EnumValuesElementType>,
                fallback: &mut Option<EnumElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.values.is_some() {
                        fallback.get_or_insert(EnumElementTypeDeserializerState::Values(None));
                        *self.state = EnumElementTypeDeserializerState::BaseType(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = EnumElementTypeDeserializerState::Values(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_values(data)?;
                        *self.state = EnumElementTypeDeserializerState::BaseType(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(EnumElementTypeDeserializerState::Values(
                                    Some(deserializer),
                                ));
                                *self.state = EnumElementTypeDeserializerState::BaseType(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    EnumElementTypeDeserializerState::Values(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_base_type<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::DataType>,
                fallback: &mut Option<EnumElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(EnumElementTypeDeserializerState::BaseType(None));
                    *self.state = EnumElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_base_type(data)?;
                        *self.state = EnumElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(EnumElementTypeDeserializerState::BaseType(
                                    Some(deserializer),
                                ));
                                *self.state = EnumElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    EnumElementTypeDeserializerState::BaseType(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::EnumElementType> for Box<EnumElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::EnumElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    EnumElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::EnumElementType>
            where
                R: DeserializeReader,
            {
                use EnumElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Values(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_values(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::BaseType(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_base_type(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = EnumElementTypeDeserializerState::Values(None);
                            event
                        }
                        (S::Values(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"values",
                                false,
                            )?;
                            match self.handle_values(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::BaseType(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"baseType",
                                true,
                            )?;
                            match self.handle_base_type(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::EnumElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    EnumElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::EnumElementType {
                    values: self
                        .values
                        .ok_or_else(|| ErrorKind::MissingElement("values".into()))?,
                    base_type: self.base_type.map(Box::new),
                })
            }
        }
        #[derive(Debug)]
        pub struct SubrangeSignedElementTypeDeserializer {
            range: Option<super::RangeSignedType>,
            base_type: Option<super::DataType>,
            state: Box<SubrangeSignedElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum SubrangeSignedElementTypeDeserializerState {
            Init__,
            Range(Option<<super::RangeSignedType as WithDeserializer>::Deserializer>),
            BaseType(Option<<super::DataType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl SubrangeSignedElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    range: None,
                    base_type: None,
                    state: Box::new(SubrangeSignedElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: SubrangeSignedElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use SubrangeSignedElementTypeDeserializerState as S;
                match state {
                    S::Range(Some(deserializer)) => {
                        self.store_range(deserializer.finish(reader)?)?
                    }
                    S::BaseType(Some(deserializer)) => {
                        self.store_base_type(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_range(&mut self, value: super::RangeSignedType) -> Result<(), Error> {
                if self.range.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"range",
                    )))?;
                }
                self.range = Some(value);
                Ok(())
            }
            fn store_base_type(&mut self, value: super::DataType) -> Result<(), Error> {
                if self.base_type.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"baseType",
                    )))?;
                }
                self.base_type = Some(value);
                Ok(())
            }
            fn handle_range<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::RangeSignedType>,
                fallback: &mut Option<SubrangeSignedElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.range.is_some() {
                        fallback
                            .get_or_insert(SubrangeSignedElementTypeDeserializerState::Range(None));
                        *self.state = SubrangeSignedElementTypeDeserializerState::BaseType(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = SubrangeSignedElementTypeDeserializerState::Range(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_range(data)?;
                        *self.state = SubrangeSignedElementTypeDeserializerState::BaseType(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    SubrangeSignedElementTypeDeserializerState::Range(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    SubrangeSignedElementTypeDeserializerState::BaseType(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = SubrangeSignedElementTypeDeserializerState::Range(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_base_type<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::DataType>,
                fallback: &mut Option<SubrangeSignedElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.base_type.is_some() {
                        fallback.get_or_insert(
                            SubrangeSignedElementTypeDeserializerState::BaseType(None),
                        );
                        *self.state = SubrangeSignedElementTypeDeserializerState::Done__;
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = SubrangeSignedElementTypeDeserializerState::BaseType(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_base_type(data)?;
                        *self.state = SubrangeSignedElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    SubrangeSignedElementTypeDeserializerState::BaseType(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = SubrangeSignedElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = SubrangeSignedElementTypeDeserializerState::BaseType(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::SubrangeSignedElementType>
            for Box<SubrangeSignedElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::SubrangeSignedElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    SubrangeSignedElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::SubrangeSignedElementType>
            where
                R: DeserializeReader,
            {
                use SubrangeSignedElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Range(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_range(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::BaseType(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_base_type(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = SubrangeSignedElementTypeDeserializerState::Range(None);
                            event
                        }
                        (S::Range(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"range",
                                false,
                            )?;
                            match self.handle_range(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::BaseType(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"baseType",
                                true,
                            )?;
                            match self.handle_base_type(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::SubrangeSignedElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    SubrangeSignedElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::SubrangeSignedElementType {
                    range: self
                        .range
                        .ok_or_else(|| ErrorKind::MissingElement("range".into()))?,
                    base_type: Box::new(
                        self.base_type
                            .ok_or_else(|| ErrorKind::MissingElement("baseType".into()))?,
                    ),
                })
            }
        }
        #[derive(Debug)]
        pub struct PointerElementTypeDeserializer {
            base_type: Option<super::DataType>,
            state: Box<PointerElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum PointerElementTypeDeserializerState {
            Init__,
            BaseType(Option<<super::DataType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl PointerElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    base_type: None,
                    state: Box::new(PointerElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: PointerElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use PointerElementTypeDeserializerState as S;
                match state {
                    S::BaseType(Some(deserializer)) => {
                        self.store_base_type(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_base_type(&mut self, value: super::DataType) -> Result<(), Error> {
                if self.base_type.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"baseType",
                    )))?;
                }
                self.base_type = Some(value);
                Ok(())
            }
            fn handle_base_type<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::DataType>,
                fallback: &mut Option<PointerElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.base_type.is_some() {
                        fallback.get_or_insert(PointerElementTypeDeserializerState::BaseType(None));
                        *self.state = PointerElementTypeDeserializerState::Done__;
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = PointerElementTypeDeserializerState::BaseType(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_base_type(data)?;
                        *self.state = PointerElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    PointerElementTypeDeserializerState::BaseType(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = PointerElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = PointerElementTypeDeserializerState::BaseType(Some(
                                    deserializer,
                                ));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::PointerElementType> for Box<PointerElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::PointerElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    PointerElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::PointerElementType>
            where
                R: DeserializeReader,
            {
                use PointerElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::BaseType(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_base_type(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = PointerElementTypeDeserializerState::BaseType(None);
                            event
                        }
                        (S::BaseType(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"baseType",
                                true,
                            )?;
                            match self.handle_base_type(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::PointerElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    PointerElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::PointerElementType {
                    base_type: Box::new(
                        self.base_type
                            .ok_or_else(|| ErrorKind::MissingElement("baseType".into()))?,
                    ),
                })
            }
        }
        #[derive(Debug)]
        pub struct ProjectFileHeaderElementTypeDeserializer {
            company_name: ::std::string::String,
            company_url: Option<::std::string::String>,
            product_name: ::std::string::String,
            product_version: ::std::string::String,
            product_release: Option<::std::string::String>,
            creation_date_time: ::std::string::String,
            content_description: Option<::std::string::String>,
            state: Box<ProjectFileHeaderElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectFileHeaderElementTypeDeserializerState {
            Init__,
            Unknown__,
        }
        impl ProjectFileHeaderElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut company_name: Option<::std::string::String> = None;
                let mut company_url: Option<::std::string::String> = None;
                let mut product_name: Option<::std::string::String> = None;
                let mut product_version: Option<::std::string::String> = None;
                let mut product_release: Option<::std::string::String> = None;
                let mut creation_date_time: Option<::std::string::String> = None;
                let mut content_description: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"companyName")
                    ) {
                        reader.read_attrib(&mut company_name, b"companyName", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"companyURL")
                    ) {
                        reader.read_attrib(&mut company_url, b"companyURL", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"productName")
                    ) {
                        reader.read_attrib(&mut product_name, b"productName", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"productVersion")
                    ) {
                        reader.read_attrib(
                            &mut product_version,
                            b"productVersion",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"productRelease")
                    ) {
                        reader.read_attrib(
                            &mut product_release,
                            b"productRelease",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"creationDateTime")
                    ) {
                        reader.read_attrib(
                            &mut creation_date_time,
                            b"creationDateTime",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"contentDescription")
                    ) {
                        reader.read_attrib(
                            &mut content_description,
                            b"contentDescription",
                            &attrib.value,
                        )?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    company_name: company_name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("companyName".into()))
                    })?,
                    company_url: company_url,
                    product_name: product_name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("productName".into()))
                    })?,
                    product_version: product_version.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("productVersion".into()))
                    })?,
                    product_release: product_release,
                    creation_date_time: creation_date_time.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("creationDateTime".into()))
                    })?,
                    content_description: content_description,
                    state: Box::new(ProjectFileHeaderElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectFileHeaderElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                Ok(())
            }
        }
        impl<'de> Deserializer<'de, super::ProjectFileHeaderElementType>
            for Box<ProjectFileHeaderElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectFileHeaderElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ProjectFileHeaderElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectFileHeaderElementType>
            where
                R: DeserializeReader,
            {
                if let Event::End(_) = &event {
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(self.finish(reader)?),
                        event: DeserializerEvent::None,
                        allow_any: false,
                    })
                } else {
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event: DeserializerEvent::Break(event),
                        allow_any: false,
                    })
                }
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::ProjectFileHeaderElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ProjectFileHeaderElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ProjectFileHeaderElementType {
                    company_name: self.company_name,
                    company_url: self.company_url,
                    product_name: self.product_name,
                    product_version: self.product_version,
                    product_release: self.product_release,
                    creation_date_time: self.creation_date_time,
                    content_description: self.content_description,
                })
            }
        }
        #[derive(Debug)]
        pub struct ProjectContentHeaderElementTypeDeserializer {
            name: ::std::string::String,
            version: Option<::std::string::String>,
            modification_date_time: Option<::std::string::String>,
            organization: Option<::std::string::String>,
            author: Option<::std::string::String>,
            language: Option<::std::string::String>,
            comment: Option<::std::string::String>,
            coordinate_info: Option<super::ProjectContentHeaderCoordinateInfoElementType>,
            add_data_info: Option<super::AddDataInfoType>,
            add_data: Option<super::AddDataType>,
            state: Box<ProjectContentHeaderElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectContentHeaderElementTypeDeserializerState {
            Init__ , Comment (Option << :: std :: string :: String as WithDeserializer > :: Deserializer >) , CoordinateInfo (Option << super :: ProjectContentHeaderCoordinateInfoElementType as WithDeserializer > :: Deserializer >) , AddDataInfo (Option << super :: AddDataInfoType as WithDeserializer > :: Deserializer >) , AddData (Option << super :: AddDataType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl ProjectContentHeaderElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                let mut version: Option<::std::string::String> = None;
                let mut modification_date_time: Option<::std::string::String> = None;
                let mut organization: Option<::std::string::String> = None;
                let mut author: Option<::std::string::String> = None;
                let mut language: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"version")
                    ) {
                        reader.read_attrib(&mut version, b"version", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"modificationDateTime")
                    ) {
                        reader.read_attrib(
                            &mut modification_date_time,
                            b"modificationDateTime",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"organization")
                    ) {
                        reader.read_attrib(&mut organization, b"organization", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"author")
                    ) {
                        reader.read_attrib(&mut author, b"author", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"language")
                    ) {
                        reader.read_attrib(&mut language, b"language", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    name: name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("name".into()))
                    })?,
                    version: version,
                    modification_date_time: modification_date_time,
                    organization: organization,
                    author: author,
                    language: language,
                    comment: None,
                    coordinate_info: None,
                    add_data_info: None,
                    add_data: None,
                    state: Box::new(ProjectContentHeaderElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectContentHeaderElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectContentHeaderElementTypeDeserializerState as S;
                match state {
                    S::Comment(Some(deserializer)) => {
                        self.store_comment(deserializer.finish(reader)?)?
                    }
                    S::CoordinateInfo(Some(deserializer)) => {
                        self.store_coordinate_info(deserializer.finish(reader)?)?
                    }
                    S::AddDataInfo(Some(deserializer)) => {
                        self.store_add_data_info(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_comment(&mut self, value: ::std::string::String) -> Result<(), Error> {
                if self.comment.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"Comment",
                    )))?;
                }
                self.comment = Some(value);
                Ok(())
            }
            fn store_coordinate_info(
                &mut self,
                value: super::ProjectContentHeaderCoordinateInfoElementType,
            ) -> Result<(), Error> {
                if self.coordinate_info.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"coordinateInfo",
                    )))?;
                }
                self.coordinate_info = Some(value);
                Ok(())
            }
            fn store_add_data_info(&mut self, value: super::AddDataInfoType) -> Result<(), Error> {
                if self.add_data_info.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addDataInfo",
                    )))?;
                }
                self.add_data_info = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn handle_comment<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, ::std::string::String>,
                fallback: &mut Option<ProjectContentHeaderElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectContentHeaderElementTypeDeserializerState::Comment(None),
                    );
                    *self.state =
                        ProjectContentHeaderElementTypeDeserializerState::CoordinateInfo(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_comment(data)?;
                        *self.state =
                            ProjectContentHeaderElementTypeDeserializerState::CoordinateInfo(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectContentHeaderElementTypeDeserializerState::Comment(
                                        Some(deserializer),
                                    ),
                                );
                                * self . state = ProjectContentHeaderElementTypeDeserializerState :: CoordinateInfo (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ProjectContentHeaderElementTypeDeserializerState::Comment(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_coordinate_info<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<
                    'de,
                    super::ProjectContentHeaderCoordinateInfoElementType,
                >,
                fallback: &mut Option<ProjectContentHeaderElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.coordinate_info.is_some() {
                        fallback.get_or_insert(
                            ProjectContentHeaderElementTypeDeserializerState::CoordinateInfo(None),
                        );
                        *self.state =
                            ProjectContentHeaderElementTypeDeserializerState::AddDataInfo(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state =
                            ProjectContentHeaderElementTypeDeserializerState::CoordinateInfo(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_coordinate_info(data)?;
                        *self.state =
                            ProjectContentHeaderElementTypeDeserializerState::AddDataInfo(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectContentHeaderElementTypeDeserializerState :: CoordinateInfo (Some (deserializer))) ;
                                *self.state =
                                    ProjectContentHeaderElementTypeDeserializerState::AddDataInfo(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectContentHeaderElementTypeDeserializerState :: CoordinateInfo (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data_info<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataInfoType>,
                fallback: &mut Option<ProjectContentHeaderElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectContentHeaderElementTypeDeserializerState::AddDataInfo(None),
                    );
                    *self.state = ProjectContentHeaderElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data_info(data)?;
                        *self.state =
                            ProjectContentHeaderElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectContentHeaderElementTypeDeserializerState::AddDataInfo(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    ProjectContentHeaderElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ProjectContentHeaderElementTypeDeserializerState::AddDataInfo(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<ProjectContentHeaderElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectContentHeaderElementTypeDeserializerState::AddData(None),
                    );
                    *self.state = ProjectContentHeaderElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = ProjectContentHeaderElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectContentHeaderElementTypeDeserializerState::AddData(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    ProjectContentHeaderElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ProjectContentHeaderElementTypeDeserializerState::AddData(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectContentHeaderElementType>
            for Box<ProjectContentHeaderElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectContentHeaderElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ProjectContentHeaderElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectContentHeaderElementType>
            where
                R: DeserializeReader,
            {
                use ProjectContentHeaderElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Comment(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_comment(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::CoordinateInfo(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_coordinate_info(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddDataInfo(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data_info(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                ProjectContentHeaderElementTypeDeserializerState::Comment(None);
                            event
                        }
                        (S::Comment(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"Comment",
                                false,
                            )?;
                            match self.handle_comment(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::CoordinateInfo(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"coordinateInfo",
                                false,
                            )?;
                            match self.handle_coordinate_info(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddDataInfo(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addDataInfo",
                                true,
                            )?;
                            match self.handle_add_data_info(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ProjectContentHeaderElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ProjectContentHeaderElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ProjectContentHeaderElementType {
                    name: self.name,
                    version: self.version,
                    modification_date_time: self.modification_date_time,
                    organization: self.organization,
                    author: self.author,
                    language: self.language,
                    comment: self.comment,
                    coordinate_info: self
                        .coordinate_info
                        .ok_or_else(|| ErrorKind::MissingElement("coordinateInfo".into()))?,
                    add_data_info: self.add_data_info,
                    add_data: self.add_data,
                })
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesElementTypeDeserializer {
            data_types: Option<super::ProjectTypesDataTypesElementType>,
            pous: Option<super::ProjectTypesPousElementType>,
            state: Box<ProjectTypesElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectTypesElementTypeDeserializerState {
            Init__,
            DataTypes(
                Option<<super::ProjectTypesDataTypesElementType as WithDeserializer>::Deserializer>,
            ),
            Pous(Option<<super::ProjectTypesPousElementType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl ProjectTypesElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    data_types: None,
                    pous: None,
                    state: Box::new(ProjectTypesElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectTypesElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectTypesElementTypeDeserializerState as S;
                match state {
                    S::DataTypes(Some(deserializer)) => {
                        self.store_data_types(deserializer.finish(reader)?)?
                    }
                    S::Pous(Some(deserializer)) => self.store_pous(deserializer.finish(reader)?)?,
                    _ => (),
                }
                Ok(())
            }
            fn store_data_types(
                &mut self,
                value: super::ProjectTypesDataTypesElementType,
            ) -> Result<(), Error> {
                if self.data_types.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"dataTypes",
                    )))?;
                }
                self.data_types = Some(value);
                Ok(())
            }
            fn store_pous(
                &mut self,
                value: super::ProjectTypesPousElementType,
            ) -> Result<(), Error> {
                if self.pous.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"pous")))?;
                }
                self.pous = Some(value);
                Ok(())
            }
            fn handle_data_types<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ProjectTypesDataTypesElementType>,
                fallback: &mut Option<ProjectTypesElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.data_types.is_some() {
                        fallback.get_or_insert(
                            ProjectTypesElementTypeDeserializerState::DataTypes(None),
                        );
                        *self.state = ProjectTypesElementTypeDeserializerState::Pous(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = ProjectTypesElementTypeDeserializerState::DataTypes(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_data_types(data)?;
                        *self.state = ProjectTypesElementTypeDeserializerState::Pous(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectTypesElementTypeDeserializerState::DataTypes(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = ProjectTypesElementTypeDeserializerState::Pous(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ProjectTypesElementTypeDeserializerState::DataTypes(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_pous<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ProjectTypesPousElementType>,
                fallback: &mut Option<ProjectTypesElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.pous.is_some() {
                        fallback
                            .get_or_insert(ProjectTypesElementTypeDeserializerState::Pous(None));
                        *self.state = ProjectTypesElementTypeDeserializerState::Done__;
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = ProjectTypesElementTypeDeserializerState::Pous(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_pous(data)?;
                        *self.state = ProjectTypesElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectTypesElementTypeDeserializerState::Pous(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = ProjectTypesElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ProjectTypesElementTypeDeserializerState::Pous(Some(
                                    deserializer,
                                ));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectTypesElementType>
            for Box<ProjectTypesElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ProjectTypesElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesElementType>
            where
                R: DeserializeReader,
            {
                use ProjectTypesElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::DataTypes(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_data_types(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Pous(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_pous(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = ProjectTypesElementTypeDeserializerState::DataTypes(None);
                            event
                        }
                        (S::DataTypes(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"dataTypes",
                                true,
                            )?;
                            match self.handle_data_types(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Pous(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"pous",
                                true,
                            )?;
                            match self.handle_pous(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::ProjectTypesElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ProjectTypesElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ProjectTypesElementType {
                    data_types: self
                        .data_types
                        .ok_or_else(|| ErrorKind::MissingElement("dataTypes".into()))?,
                    pous: self
                        .pous
                        .ok_or_else(|| ErrorKind::MissingElement("pous".into()))?,
                })
            }
        }
        #[derive(Debug)]
        pub struct ProjectInstancesElementTypeDeserializer {
            configurations: Option<super::ProjectInstancesConfigurationsElementType>,
            state: Box<ProjectInstancesElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectInstancesElementTypeDeserializerState {
            Init__ , Configurations (Option << super :: ProjectInstancesConfigurationsElementType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl ProjectInstancesElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    configurations: None,
                    state: Box::new(ProjectInstancesElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectInstancesElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectInstancesElementTypeDeserializerState as S;
                match state {
                    S::Configurations(Some(deserializer)) => {
                        self.store_configurations(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_configurations(
                &mut self,
                value: super::ProjectInstancesConfigurationsElementType,
            ) -> Result<(), Error> {
                if self.configurations.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"configurations",
                    )))?;
                }
                self.configurations = Some(value);
                Ok(())
            }
            fn handle_configurations<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ProjectInstancesConfigurationsElementType>,
                fallback: &mut Option<ProjectInstancesElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.configurations.is_some() {
                        fallback.get_or_insert(
                            ProjectInstancesElementTypeDeserializerState::Configurations(None),
                        );
                        *self.state = ProjectInstancesElementTypeDeserializerState::Done__;
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state =
                            ProjectInstancesElementTypeDeserializerState::Configurations(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_configurations(data)?;
                        *self.state = ProjectInstancesElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectInstancesElementTypeDeserializerState::Configurations(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state = ProjectInstancesElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ProjectInstancesElementTypeDeserializerState::Configurations(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectInstancesElementType>
            for Box<ProjectInstancesElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectInstancesElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ProjectInstancesElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectInstancesElementType>
            where
                R: DeserializeReader,
            {
                use ProjectInstancesElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Configurations(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_configurations(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                ProjectInstancesElementTypeDeserializerState::Configurations(None);
                            event
                        }
                        (S::Configurations(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"configurations",
                                true,
                            )?;
                            match self.handle_configurations(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::ProjectInstancesElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ProjectInstancesElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ProjectInstancesElementType {
                    configurations: self
                        .configurations
                        .ok_or_else(|| ErrorKind::MissingElement("configurations".into()))?,
                })
            }
        }
        #[derive(Debug)]
        pub struct ValueSimpleValueElementTypeDeserializer {
            value: Option<::std::string::String>,
            state: Box<ValueSimpleValueElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ValueSimpleValueElementTypeDeserializerState {
            Init__,
            Unknown__,
        }
        impl ValueSimpleValueElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut value: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"value")
                    ) {
                        reader.read_attrib(&mut value, b"value", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    value: value,
                    state: Box::new(ValueSimpleValueElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ValueSimpleValueElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                Ok(())
            }
        }
        impl<'de> Deserializer<'de, super::ValueSimpleValueElementType>
            for Box<ValueSimpleValueElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueSimpleValueElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ValueSimpleValueElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueSimpleValueElementType>
            where
                R: DeserializeReader,
            {
                if let Event::End(_) = &event {
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(self.finish(reader)?),
                        event: DeserializerEvent::None,
                        allow_any: false,
                    })
                } else {
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event: DeserializerEvent::Break(event),
                        allow_any: false,
                    })
                }
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::ValueSimpleValueElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ValueSimpleValueElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ValueSimpleValueElementType { value: self.value })
            }
        }
        #[derive(Debug)]
        pub struct ValueArrayValueElementTypeDeserializer {
            content: Vec<super::ValueArrayValueElementTypeContent>,
            state: Box<ValueArrayValueElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ValueArrayValueElementTypeDeserializerState {
            Init__,
            Next__,
            Content__(<super::ValueArrayValueElementTypeContent as WithDeserializer>::Deserializer),
            Unknown__,
        }
        impl ValueArrayValueElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    content: Vec::new(),
                    state: Box::new(ValueArrayValueElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ValueArrayValueElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                if let ValueArrayValueElementTypeDeserializerState::Content__(deserializer) = state
                {
                    self.store_content(deserializer.finish(reader)?)?;
                }
                Ok(())
            }
            fn store_content(
                &mut self,
                value: super::ValueArrayValueElementTypeContent,
            ) -> Result<(), Error> {
                self.content.push(value);
                Ok(())
            }
            fn handle_content<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ValueArrayValueElementTypeContent>,
                fallback: &mut Option<ValueArrayValueElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = fallback
                        .take()
                        .unwrap_or(ValueArrayValueElementTypeDeserializerState::Next__);
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_content(data)?;
                        *self.state = ValueArrayValueElementTypeDeserializerState::Next__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ValueArrayValueElementTypeDeserializerState::Content__(
                                        deserializer,
                                    );
                            }
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ValueArrayValueElementTypeDeserializerState::Content__(
                                        deserializer,
                                    ),
                                );
                                *self.state = ValueArrayValueElementTypeDeserializerState::Next__;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ValueArrayValueElementType>
            for Box<ValueArrayValueElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueArrayValueElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ValueArrayValueElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueArrayValueElementType>
            where
                R: DeserializeReader,
            {
                use ValueArrayValueElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Content__(deserializer), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (_, Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (state @ (S::Init__ | S::Next__), event) => {
                            fallback.get_or_insert(state);
                            let output = < super :: ValueArrayValueElementTypeContent as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = DeserializerArtifact::Deserializer(self);
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::ValueArrayValueElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ValueArrayValueElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ValueArrayValueElementType {
                    content: self.content,
                })
            }
        }
        #[derive(Debug)]
        pub struct ValueArrayValueElementTypeContentDeserializer {
            value: Option<super::ValueArrayValueValueElementType>,
            state: Box<ValueArrayValueElementTypeContentDeserializerState>,
        }
        #[derive(Debug)]
        enum ValueArrayValueElementTypeContentDeserializerState {
            Init__,
            Value(
                Option<<super::ValueArrayValueValueElementType as WithDeserializer>::Deserializer>,
            ),
            Done__,
            Unknown__,
        }
        impl ValueArrayValueElementTypeContentDeserializer {
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ValueArrayValueElementTypeContentDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ValueArrayValueElementTypeContentDeserializerState as S;
                match state {
                    S::Value(Some(deserializer)) => {
                        self.store_value(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_value(
                &mut self,
                value: super::ValueArrayValueValueElementType,
            ) -> Result<(), Error> {
                if self.value.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"value",
                    )))?;
                }
                self.value = Some(value);
                Ok(())
            }
            fn handle_value<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ValueArrayValueValueElementType>,
                fallback: &mut Option<ValueArrayValueElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.value.is_some() {
                        fallback.get_or_insert(
                            ValueArrayValueElementTypeContentDeserializerState::Value(None),
                        );
                        *self.state = ValueArrayValueElementTypeContentDeserializerState::Done__;
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state =
                            ValueArrayValueElementTypeContentDeserializerState::Value(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_value(data)?;
                        *self.state = ValueArrayValueElementTypeContentDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ValueArrayValueElementTypeContentDeserializerState::Value(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    ValueArrayValueElementTypeContentDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ValueArrayValueElementTypeContentDeserializerState::Value(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ValueArrayValueElementTypeContent>
            for Box<ValueArrayValueElementTypeContentDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueArrayValueElementTypeContent>
            where
                R: DeserializeReader,
            {
                let deserializer = Box::new(ValueArrayValueElementTypeContentDeserializer {
                    value: None,
                    state: Box::new(ValueArrayValueElementTypeContentDeserializerState::Init__),
                });
                let mut output = deserializer.next(reader, event)?;
                output.artifact = match output.artifact {
                    DeserializerArtifact::Deserializer(x)
                        if matches!(
                            &*x.state,
                            ValueArrayValueElementTypeContentDeserializerState::Init__
                        ) =>
                    {
                        DeserializerArtifact::None
                    }
                    artifact => artifact,
                };
                Ok(output)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueArrayValueElementTypeContent>
            where
                R: DeserializeReader,
            {
                use ValueArrayValueElementTypeContentDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Value(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_value(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, event @ Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::Continue(event),
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                ValueArrayValueElementTypeContentDeserializerState::Value(None);
                            event
                        }
                        (S::Value(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"value",
                                false,
                            )?;
                            match self.handle_value(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ValueArrayValueElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ValueArrayValueElementTypeContentDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ValueArrayValueElementTypeContent {
                    value: self
                        .value
                        .ok_or_else(|| ErrorKind::MissingElement("value".into()))?,
                })
            }
        }
        #[derive(Debug)]
        pub struct ValueStructValueElementTypeDeserializer {
            content: Vec<super::ValueStructValueElementTypeContent>,
            state: Box<ValueStructValueElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ValueStructValueElementTypeDeserializerState {
            Init__,
            Next__,
            Content__(
                <super::ValueStructValueElementTypeContent as WithDeserializer>::Deserializer,
            ),
            Unknown__,
        }
        impl ValueStructValueElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    content: Vec::new(),
                    state: Box::new(ValueStructValueElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ValueStructValueElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                if let ValueStructValueElementTypeDeserializerState::Content__(deserializer) = state
                {
                    self.store_content(deserializer.finish(reader)?)?;
                }
                Ok(())
            }
            fn store_content(
                &mut self,
                value: super::ValueStructValueElementTypeContent,
            ) -> Result<(), Error> {
                self.content.push(value);
                Ok(())
            }
            fn handle_content<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ValueStructValueElementTypeContent>,
                fallback: &mut Option<ValueStructValueElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = fallback
                        .take()
                        .unwrap_or(ValueStructValueElementTypeDeserializerState::Next__);
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_content(data)?;
                        *self.state = ValueStructValueElementTypeDeserializerState::Next__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ValueStructValueElementTypeDeserializerState::Content__(
                                        deserializer,
                                    );
                            }
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ValueStructValueElementTypeDeserializerState::Content__(
                                        deserializer,
                                    ),
                                );
                                *self.state = ValueStructValueElementTypeDeserializerState::Next__;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ValueStructValueElementType>
            for Box<ValueStructValueElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueStructValueElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ValueStructValueElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueStructValueElementType>
            where
                R: DeserializeReader,
            {
                use ValueStructValueElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Content__(deserializer), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (_, Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (state @ (S::Init__ | S::Next__), event) => {
                            fallback.get_or_insert(state);
                            let output = < super :: ValueStructValueElementTypeContent as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = DeserializerArtifact::Deserializer(self);
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::ValueStructValueElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ValueStructValueElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ValueStructValueElementType {
                    content: self.content,
                })
            }
        }
        #[derive(Debug)]
        pub struct ValueStructValueElementTypeContentDeserializer {
            value: Option<super::ValueStructValueValueElementType>,
            state: Box<ValueStructValueElementTypeContentDeserializerState>,
        }
        #[derive(Debug)]
        enum ValueStructValueElementTypeContentDeserializerState {
            Init__,
            Value(
                Option<<super::ValueStructValueValueElementType as WithDeserializer>::Deserializer>,
            ),
            Done__,
            Unknown__,
        }
        impl ValueStructValueElementTypeContentDeserializer {
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ValueStructValueElementTypeContentDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ValueStructValueElementTypeContentDeserializerState as S;
                match state {
                    S::Value(Some(deserializer)) => {
                        self.store_value(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_value(
                &mut self,
                value: super::ValueStructValueValueElementType,
            ) -> Result<(), Error> {
                if self.value.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"value",
                    )))?;
                }
                self.value = Some(value);
                Ok(())
            }
            fn handle_value<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ValueStructValueValueElementType>,
                fallback: &mut Option<ValueStructValueElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.value.is_some() {
                        fallback.get_or_insert(
                            ValueStructValueElementTypeContentDeserializerState::Value(None),
                        );
                        *self.state = ValueStructValueElementTypeContentDeserializerState::Done__;
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state =
                            ValueStructValueElementTypeContentDeserializerState::Value(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_value(data)?;
                        *self.state = ValueStructValueElementTypeContentDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ValueStructValueElementTypeContentDeserializerState::Value(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    ValueStructValueElementTypeContentDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ValueStructValueElementTypeContentDeserializerState::Value(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ValueStructValueElementTypeContent>
            for Box<ValueStructValueElementTypeContentDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueStructValueElementTypeContent>
            where
                R: DeserializeReader,
            {
                let deserializer = Box::new(ValueStructValueElementTypeContentDeserializer {
                    value: None,
                    state: Box::new(ValueStructValueElementTypeContentDeserializerState::Init__),
                });
                let mut output = deserializer.next(reader, event)?;
                output.artifact = match output.artifact {
                    DeserializerArtifact::Deserializer(x)
                        if matches!(
                            &*x.state,
                            ValueStructValueElementTypeContentDeserializerState::Init__
                        ) =>
                    {
                        DeserializerArtifact::None
                    }
                    artifact => artifact,
                };
                Ok(output)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueStructValueElementTypeContent>
            where
                R: DeserializeReader,
            {
                use ValueStructValueElementTypeContentDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Value(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_value(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, event @ Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::Continue(event),
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                ValueStructValueElementTypeContentDeserializerState::Value(None);
                            event
                        }
                        (S::Value(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"value",
                                false,
                            )?;
                            match self.handle_value(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ValueStructValueElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ValueStructValueElementTypeContentDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ValueStructValueElementTypeContent {
                    value: self
                        .value
                        .ok_or_else(|| ErrorKind::MissingElement("value".into()))?,
                })
            }
        }
        #[derive(Debug)]
        pub struct VarListPlainVariableElementTypeDeserializer {
            name: ::std::string::String,
            address: Option<::std::string::String>,
            global_id: Option<::std::string::String>,
            type_: Option<super::DataType>,
            initial_value: Option<super::ValueType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<VarListPlainVariableElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum VarListPlainVariableElementTypeDeserializerState {
            Init__,
            Type(Option<<super::DataType as WithDeserializer>::Deserializer>),
            InitialValue(Option<<super::ValueType as WithDeserializer>::Deserializer>),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl VarListPlainVariableElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                let mut address: Option<::std::string::String> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"address")
                    ) {
                        reader.read_attrib(&mut address, b"address", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    name: name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("name".into()))
                    })?,
                    address: address,
                    global_id: global_id,
                    type_: None,
                    initial_value: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(VarListPlainVariableElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: VarListPlainVariableElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use VarListPlainVariableElementTypeDeserializerState as S;
                match state {
                    S::Type(Some(deserializer)) => {
                        self.store_type_(deserializer.finish(reader)?)?
                    }
                    S::InitialValue(Some(deserializer)) => {
                        self.store_initial_value(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_type_(&mut self, value: super::DataType) -> Result<(), Error> {
                if self.type_.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"type")))?;
                }
                self.type_ = Some(value);
                Ok(())
            }
            fn store_initial_value(&mut self, value: super::ValueType) -> Result<(), Error> {
                if self.initial_value.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"initialValue",
                    )))?;
                }
                self.initial_value = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_type_<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::DataType>,
                fallback: &mut Option<VarListPlainVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.type_.is_some() {
                        fallback.get_or_insert(
                            VarListPlainVariableElementTypeDeserializerState::Type(None),
                        );
                        *self.state =
                            VarListPlainVariableElementTypeDeserializerState::InitialValue(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = VarListPlainVariableElementTypeDeserializerState::Type(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_type_(data)?;
                        *self.state =
                            VarListPlainVariableElementTypeDeserializerState::InitialValue(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VarListPlainVariableElementTypeDeserializerState::Type(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    VarListPlainVariableElementTypeDeserializerState::InitialValue(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    VarListPlainVariableElementTypeDeserializerState::Type(Some(
                                        deserializer,
                                    ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_initial_value<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ValueType>,
                fallback: &mut Option<VarListPlainVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        VarListPlainVariableElementTypeDeserializerState::InitialValue(None),
                    );
                    *self.state = VarListPlainVariableElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_initial_value(data)?;
                        *self.state =
                            VarListPlainVariableElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VarListPlainVariableElementTypeDeserializerState::InitialValue(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    VarListPlainVariableElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    VarListPlainVariableElementTypeDeserializerState::InitialValue(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<VarListPlainVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        VarListPlainVariableElementTypeDeserializerState::AddData(None),
                    );
                    *self.state =
                        VarListPlainVariableElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state =
                            VarListPlainVariableElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VarListPlainVariableElementTypeDeserializerState::AddData(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    VarListPlainVariableElementTypeDeserializerState::Documentation(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    VarListPlainVariableElementTypeDeserializerState::AddData(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<VarListPlainVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        VarListPlainVariableElementTypeDeserializerState::Documentation(None),
                    );
                    *self.state = VarListPlainVariableElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = VarListPlainVariableElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VarListPlainVariableElementTypeDeserializerState::Documentation(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    VarListPlainVariableElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    VarListPlainVariableElementTypeDeserializerState::Documentation(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::VarListPlainVariableElementType>
            for Box<VarListPlainVariableElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::VarListPlainVariableElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    VarListPlainVariableElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::VarListPlainVariableElementType>
            where
                R: DeserializeReader,
            {
                use VarListPlainVariableElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Type(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_type_(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::InitialValue(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_initial_value(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                VarListPlainVariableElementTypeDeserializerState::Type(None);
                            event
                        }
                        (S::Type(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"type",
                                true,
                            )?;
                            match self.handle_type_(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::InitialValue(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"initialValue",
                                false,
                            )?;
                            match self.handle_initial_value(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::VarListPlainVariableElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    VarListPlainVariableElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::VarListPlainVariableElementType {
                    name: self.name,
                    address: self.address,
                    global_id: self.global_id,
                    type_: self
                        .type_
                        .ok_or_else(|| ErrorKind::MissingElement("type".into()))?,
                    initial_value: self.initial_value,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct VarListAccessAccessVariableElementTypeDeserializer {
            alias: ::std::string::String,
            instance_path_and_name: ::std::string::String,
            direction: Option<super::AccessType>,
            type_: Option<super::DataType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<VarListAccessAccessVariableElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum VarListAccessAccessVariableElementTypeDeserializerState {
            Init__,
            Type(Option<<super::DataType as WithDeserializer>::Deserializer>),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl VarListAccessAccessVariableElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut alias: Option<::std::string::String> = None;
                let mut instance_path_and_name: Option<::std::string::String> = None;
                let mut direction: Option<super::AccessType> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"alias")
                    ) {
                        reader.read_attrib(&mut alias, b"alias", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"instancePathAndName")
                    ) {
                        reader.read_attrib(
                            &mut instance_path_and_name,
                            b"instancePathAndName",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"direction")
                    ) {
                        reader.read_attrib(&mut direction, b"direction", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    alias: alias.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("alias".into()))
                    })?,
                    instance_path_and_name: instance_path_and_name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("instancePathAndName".into()))
                    })?,
                    direction: direction,
                    type_: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(
                        VarListAccessAccessVariableElementTypeDeserializerState::Init__,
                    ),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: VarListAccessAccessVariableElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use VarListAccessAccessVariableElementTypeDeserializerState as S;
                match state {
                    S::Type(Some(deserializer)) => {
                        self.store_type_(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_type_(&mut self, value: super::DataType) -> Result<(), Error> {
                if self.type_.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"type")))?;
                }
                self.type_ = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_type_<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::DataType>,
                fallback: &mut Option<VarListAccessAccessVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.type_.is_some() {
                        fallback.get_or_insert(
                            VarListAccessAccessVariableElementTypeDeserializerState::Type(None),
                        );
                        *self.state =
                            VarListAccessAccessVariableElementTypeDeserializerState::AddData(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state =
                            VarListAccessAccessVariableElementTypeDeserializerState::Type(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_type_(data)?;
                        *self.state =
                            VarListAccessAccessVariableElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VarListAccessAccessVariableElementTypeDeserializerState::Type(
                                        Some(deserializer),
                                    ),
                                );
                                * self . state = VarListAccessAccessVariableElementTypeDeserializerState :: AddData (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    VarListAccessAccessVariableElementTypeDeserializerState::Type(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<VarListAccessAccessVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        VarListAccessAccessVariableElementTypeDeserializerState::AddData(None),
                    );
                    *self.state =
                        VarListAccessAccessVariableElementTypeDeserializerState::Documentation(
                            None,
                        );
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state =
                            VarListAccessAccessVariableElementTypeDeserializerState::Documentation(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (VarListAccessAccessVariableElementTypeDeserializerState :: AddData (Some (deserializer))) ;
                                * self . state = VarListAccessAccessVariableElementTypeDeserializerState :: Documentation (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = VarListAccessAccessVariableElementTypeDeserializerState :: AddData (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<VarListAccessAccessVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        VarListAccessAccessVariableElementTypeDeserializerState::Documentation(
                            None,
                        ),
                    );
                    *self.state = VarListAccessAccessVariableElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state =
                            VarListAccessAccessVariableElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (VarListAccessAccessVariableElementTypeDeserializerState :: Documentation (Some (deserializer))) ;
                                *self.state =
                                    VarListAccessAccessVariableElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = VarListAccessAccessVariableElementTypeDeserializerState :: Documentation (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::VarListAccessAccessVariableElementType>
            for Box<VarListAccessAccessVariableElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::VarListAccessAccessVariableElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    VarListAccessAccessVariableElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::VarListAccessAccessVariableElementType>
            where
                R: DeserializeReader,
            {
                use VarListAccessAccessVariableElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Type(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_type_(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                VarListAccessAccessVariableElementTypeDeserializerState::Type(None);
                            event
                        }
                        (S::Type(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"type",
                                true,
                            )?;
                            match self.handle_type_(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::VarListAccessAccessVariableElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    VarListAccessAccessVariableElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::VarListAccessAccessVariableElementType {
                    alias: self.alias,
                    instance_path_and_name: self.instance_path_and_name,
                    direction: self.direction,
                    type_: self
                        .type_
                        .ok_or_else(|| ErrorKind::MissingElement("type".into()))?,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct VarListConfigConfigVariableElementTypeDeserializer {
            instance_path_and_name: ::std::string::String,
            address: Option<::std::string::String>,
            type_: Option<super::DataType>,
            initial_value: Option<super::ValueType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<VarListConfigConfigVariableElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum VarListConfigConfigVariableElementTypeDeserializerState {
            Init__,
            Type(Option<<super::DataType as WithDeserializer>::Deserializer>),
            InitialValue(Option<<super::ValueType as WithDeserializer>::Deserializer>),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl VarListConfigConfigVariableElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut instance_path_and_name: Option<::std::string::String> = None;
                let mut address: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"instancePathAndName")
                    ) {
                        reader.read_attrib(
                            &mut instance_path_and_name,
                            b"instancePathAndName",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"address")
                    ) {
                        reader.read_attrib(&mut address, b"address", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    instance_path_and_name: instance_path_and_name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("instancePathAndName".into()))
                    })?,
                    address: address,
                    type_: None,
                    initial_value: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(
                        VarListConfigConfigVariableElementTypeDeserializerState::Init__,
                    ),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: VarListConfigConfigVariableElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use VarListConfigConfigVariableElementTypeDeserializerState as S;
                match state {
                    S::Type(Some(deserializer)) => {
                        self.store_type_(deserializer.finish(reader)?)?
                    }
                    S::InitialValue(Some(deserializer)) => {
                        self.store_initial_value(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_type_(&mut self, value: super::DataType) -> Result<(), Error> {
                if self.type_.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"type")))?;
                }
                self.type_ = Some(value);
                Ok(())
            }
            fn store_initial_value(&mut self, value: super::ValueType) -> Result<(), Error> {
                if self.initial_value.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"initialValue",
                    )))?;
                }
                self.initial_value = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_type_<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::DataType>,
                fallback: &mut Option<VarListConfigConfigVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.type_.is_some() {
                        fallback.get_or_insert(
                            VarListConfigConfigVariableElementTypeDeserializerState::Type(None),
                        );
                        *self.state =
                            VarListConfigConfigVariableElementTypeDeserializerState::InitialValue(
                                None,
                            );
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state =
                            VarListConfigConfigVariableElementTypeDeserializerState::Type(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_type_(data)?;
                        *self.state =
                            VarListConfigConfigVariableElementTypeDeserializerState::InitialValue(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VarListConfigConfigVariableElementTypeDeserializerState::Type(
                                        Some(deserializer),
                                    ),
                                );
                                * self . state = VarListConfigConfigVariableElementTypeDeserializerState :: InitialValue (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    VarListConfigConfigVariableElementTypeDeserializerState::Type(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_initial_value<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ValueType>,
                fallback: &mut Option<VarListConfigConfigVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        VarListConfigConfigVariableElementTypeDeserializerState::InitialValue(None),
                    );
                    *self.state =
                        VarListConfigConfigVariableElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_initial_value(data)?;
                        *self.state =
                            VarListConfigConfigVariableElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (VarListConfigConfigVariableElementTypeDeserializerState :: InitialValue (Some (deserializer))) ;
                                * self . state = VarListConfigConfigVariableElementTypeDeserializerState :: AddData (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = VarListConfigConfigVariableElementTypeDeserializerState :: InitialValue (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<VarListConfigConfigVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        VarListConfigConfigVariableElementTypeDeserializerState::AddData(None),
                    );
                    *self.state =
                        VarListConfigConfigVariableElementTypeDeserializerState::Documentation(
                            None,
                        );
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state =
                            VarListConfigConfigVariableElementTypeDeserializerState::Documentation(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (VarListConfigConfigVariableElementTypeDeserializerState :: AddData (Some (deserializer))) ;
                                * self . state = VarListConfigConfigVariableElementTypeDeserializerState :: Documentation (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = VarListConfigConfigVariableElementTypeDeserializerState :: AddData (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<VarListConfigConfigVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        VarListConfigConfigVariableElementTypeDeserializerState::Documentation(
                            None,
                        ),
                    );
                    *self.state = VarListConfigConfigVariableElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state =
                            VarListConfigConfigVariableElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (VarListConfigConfigVariableElementTypeDeserializerState :: Documentation (Some (deserializer))) ;
                                *self.state =
                                    VarListConfigConfigVariableElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = VarListConfigConfigVariableElementTypeDeserializerState :: Documentation (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::VarListConfigConfigVariableElementType>
            for Box<VarListConfigConfigVariableElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::VarListConfigConfigVariableElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    VarListConfigConfigVariableElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::VarListConfigConfigVariableElementType>
            where
                R: DeserializeReader,
            {
                use VarListConfigConfigVariableElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Type(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_type_(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::InitialValue(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_initial_value(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                VarListConfigConfigVariableElementTypeDeserializerState::Type(None);
                            event
                        }
                        (S::Type(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"type",
                                true,
                            )?;
                            match self.handle_type_(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::InitialValue(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"initialValue",
                                false,
                            )?;
                            match self.handle_initial_value(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::VarListConfigConfigVariableElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    VarListConfigConfigVariableElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::VarListConfigConfigVariableElementType {
                    instance_path_and_name: self.instance_path_and_name,
                    address: self.address,
                    type_: self
                        .type_
                        .ok_or_else(|| ErrorKind::MissingElement("type".into()))?,
                    initial_value: self.initial_value,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct CommentElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: ::core::primitive::f64,
            width: ::core::primitive::f64,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            content: Option<super::FormattedTextType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<CommentElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum CommentElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            Content(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl CommentElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("height".into()))
                    })?,
                    width: width.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("width".into()))
                    })?,
                    global_id: global_id,
                    position: None,
                    content: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(CommentElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: CommentElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use CommentElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::Content(Some(deserializer)) => {
                        self.store_content(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_content(&mut self, value: super::FormattedTextType) -> Result<(), Error> {
                if self.content.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"content",
                    )))?;
                }
                self.content = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<CommentElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback.get_or_insert(CommentElementTypeDeserializerState::Position(None));
                        *self.state = CommentElementTypeDeserializerState::Content(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = CommentElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state = CommentElementTypeDeserializerState::Content(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    CommentElementTypeDeserializerState::Position(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = CommentElementTypeDeserializerState::Content(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = CommentElementTypeDeserializerState::Position(Some(
                                    deserializer,
                                ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_content<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<CommentElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.content.is_some() {
                        fallback.get_or_insert(CommentElementTypeDeserializerState::Content(None));
                        *self.state = CommentElementTypeDeserializerState::AddData(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = CommentElementTypeDeserializerState::Content(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_content(data)?;
                        *self.state = CommentElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    CommentElementTypeDeserializerState::Content(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = CommentElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = CommentElementTypeDeserializerState::Content(Some(
                                    deserializer,
                                ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<CommentElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(CommentElementTypeDeserializerState::AddData(None));
                    *self.state = CommentElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = CommentElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    CommentElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    CommentElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = CommentElementTypeDeserializerState::AddData(Some(
                                    deserializer,
                                ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<CommentElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(CommentElementTypeDeserializerState::Documentation(None));
                    *self.state = CommentElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = CommentElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    CommentElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = CommentElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = CommentElementTypeDeserializerState::Documentation(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::CommentElementType> for Box<CommentElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::CommentElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    CommentElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::CommentElementType>
            where
                R: DeserializeReader,
            {
                use CommentElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Content(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = CommentElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Content(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"content",
                                true,
                            )?;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::CommentElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    CommentElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::CommentElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    content: self
                        .content
                        .ok_or_else(|| ErrorKind::MissingElement("content".into()))?,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct ConnectorElementTypeDeserializer {
            name: ::std::string::String,
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_in: Option<super::ConnectionPointInType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<ConnectorElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ConnectorElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            ConnectionPointIn(
                Option<<super::ConnectionPointInType as WithDeserializer>::Deserializer>,
            ),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl ConnectorElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    name: name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("name".into()))
                    })?,
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    global_id: global_id,
                    position: None,
                    connection_point_in: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(ConnectorElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ConnectorElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ConnectorElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                if self.connection_point_in.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointIn",
                    )))?;
                }
                self.connection_point_in = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<ConnectorElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback
                            .get_or_insert(ConnectorElementTypeDeserializerState::Position(None));
                        *self.state =
                            ConnectorElementTypeDeserializerState::ConnectionPointIn(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = ConnectorElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state =
                            ConnectorElementTypeDeserializerState::ConnectionPointIn(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ConnectorElementTypeDeserializerState::Position(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    ConnectorElementTypeDeserializerState::ConnectionPointIn(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ConnectorElementTypeDeserializerState::Position(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<ConnectorElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ConnectorElementTypeDeserializerState::ConnectionPointIn(None),
                    );
                    *self.state = ConnectorElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        *self.state = ConnectorElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ConnectorElementTypeDeserializerState::ConnectionPointIn(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = ConnectorElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ConnectorElementTypeDeserializerState::ConnectionPointIn(Some(
                                        deserializer,
                                    ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<ConnectorElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(ConnectorElementTypeDeserializerState::AddData(None));
                    *self.state = ConnectorElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = ConnectorElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ConnectorElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    ConnectorElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ConnectorElementTypeDeserializerState::AddData(Some(
                                    deserializer,
                                ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<ConnectorElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(ConnectorElementTypeDeserializerState::Documentation(None));
                    *self.state = ConnectorElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = ConnectorElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ConnectorElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = ConnectorElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ConnectorElementTypeDeserializerState::Documentation(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ConnectorElementType> for Box<ConnectorElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ConnectorElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ConnectorElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ConnectorElementType>
            where
                R: DeserializeReader,
            {
                use ConnectorElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = ConnectorElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::ConnectorElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ConnectorElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ConnectorElementType {
                    name: self.name,
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_in: self.connection_point_in,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct ContinuationElementTypeDeserializer {
            name: ::std::string::String,
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_out: Option<super::ConnectionPointOutType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<ContinuationElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ContinuationElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            ConnectionPointOut(
                Option<<super::ConnectionPointOutType as WithDeserializer>::Deserializer>,
            ),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl ContinuationElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    name: name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("name".into()))
                    })?,
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    global_id: global_id,
                    position: None,
                    connection_point_out: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(ContinuationElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ContinuationElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ContinuationElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointOut(Some(deserializer)) => {
                        self.store_connection_point_out(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_out(
                &mut self,
                value: super::ConnectionPointOutType,
            ) -> Result<(), Error> {
                if self.connection_point_out.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointOut",
                    )))?;
                }
                self.connection_point_out = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<ContinuationElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback.get_or_insert(ContinuationElementTypeDeserializerState::Position(
                            None,
                        ));
                        *self.state =
                            ContinuationElementTypeDeserializerState::ConnectionPointOut(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = ContinuationElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state =
                            ContinuationElementTypeDeserializerState::ConnectionPointOut(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ContinuationElementTypeDeserializerState::Position(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    ContinuationElementTypeDeserializerState::ConnectionPointOut(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ContinuationElementTypeDeserializerState::Position(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_out<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointOutType>,
                fallback: &mut Option<ContinuationElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ContinuationElementTypeDeserializerState::ConnectionPointOut(None),
                    );
                    *self.state = ContinuationElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_out(data)?;
                        *self.state = ContinuationElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ContinuationElementTypeDeserializerState::ConnectionPointOut(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    ContinuationElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ContinuationElementTypeDeserializerState::ConnectionPointOut(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<ContinuationElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(ContinuationElementTypeDeserializerState::AddData(None));
                    *self.state = ContinuationElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = ContinuationElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ContinuationElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    ContinuationElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ContinuationElementTypeDeserializerState::AddData(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<ContinuationElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ContinuationElementTypeDeserializerState::Documentation(None),
                    );
                    *self.state = ContinuationElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = ContinuationElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ContinuationElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = ContinuationElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ContinuationElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    ));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ContinuationElementType>
            for Box<ContinuationElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ContinuationElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ContinuationElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ContinuationElementType>
            where
                R: DeserializeReader,
            {
                use ContinuationElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointOut(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = ContinuationElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointOut(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointOut",
                                false,
                            )?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::ContinuationElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ContinuationElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ContinuationElementType {
                    name: self.name,
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_out: self.connection_point_out,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct ActionBlockElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            negated: ::core::primitive::bool,
            width: Option<::core::primitive::f64>,
            height: Option<::core::primitive::f64>,
            execution_order_id: Option<::core::primitive::u64>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_in: Option<super::ConnectionPointInType>,
            action: Vec<super::ActionBlockActionElementType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<ActionBlockElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ActionBlockElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            ConnectionPointIn(
                Option<<super::ConnectionPointInType as WithDeserializer>::Deserializer>,
            ),
            Action(Option<<super::ActionBlockActionElementType as WithDeserializer>::Deserializer>),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl ActionBlockElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut negated: Option<::core::primitive::bool> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut execution_order_id: Option<::core::primitive::u64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"negated")
                    ) {
                        reader.read_attrib(&mut negated, b"negated", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"executionOrderId")
                    ) {
                        reader.read_attrib(
                            &mut execution_order_id,
                            b"executionOrderId",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    negated: negated.unwrap_or_else(super::ActionBlockElementType::default_negated),
                    width: width,
                    height: height,
                    execution_order_id: execution_order_id,
                    global_id: global_id,
                    position: None,
                    connection_point_in: None,
                    action: Vec::new(),
                    add_data: None,
                    documentation: None,
                    state: Box::new(ActionBlockElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ActionBlockElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ActionBlockElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::Action(Some(deserializer)) => {
                        self.store_action(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                if self.connection_point_in.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointIn",
                    )))?;
                }
                self.connection_point_in = Some(value);
                Ok(())
            }
            fn store_action(
                &mut self,
                value: super::ActionBlockActionElementType,
            ) -> Result<(), Error> {
                self.action.push(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<ActionBlockElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback
                            .get_or_insert(ActionBlockElementTypeDeserializerState::Position(None));
                        *self.state =
                            ActionBlockElementTypeDeserializerState::ConnectionPointIn(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = ActionBlockElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state =
                            ActionBlockElementTypeDeserializerState::ConnectionPointIn(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ActionBlockElementTypeDeserializerState::Position(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    ActionBlockElementTypeDeserializerState::ConnectionPointIn(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ActionBlockElementTypeDeserializerState::Position(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<ActionBlockElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ActionBlockElementTypeDeserializerState::ConnectionPointIn(None),
                    );
                    *self.state = ActionBlockElementTypeDeserializerState::Action(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        *self.state = ActionBlockElementTypeDeserializerState::Action(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ActionBlockElementTypeDeserializerState::ConnectionPointIn(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state = ActionBlockElementTypeDeserializerState::Action(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ActionBlockElementTypeDeserializerState::ConnectionPointIn(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_action<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ActionBlockActionElementType>,
                fallback: &mut Option<ActionBlockElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(ActionBlockElementTypeDeserializerState::Action(None));
                    *self.state = ActionBlockElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_action(data)?;
                        *self.state = ActionBlockElementTypeDeserializerState::Action(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ActionBlockElementTypeDeserializerState::Action(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = ActionBlockElementTypeDeserializerState::Action(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ActionBlockElementTypeDeserializerState::Action(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<ActionBlockElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(ActionBlockElementTypeDeserializerState::AddData(None));
                    *self.state = ActionBlockElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = ActionBlockElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ActionBlockElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    ActionBlockElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ActionBlockElementTypeDeserializerState::AddData(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<ActionBlockElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(ActionBlockElementTypeDeserializerState::Documentation(
                        None,
                    ));
                    *self.state = ActionBlockElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = ActionBlockElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ActionBlockElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = ActionBlockElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ActionBlockElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    ));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ActionBlockElementType>
            for Box<ActionBlockElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ActionBlockElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ActionBlockElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ActionBlockElementType>
            where
                R: DeserializeReader,
            {
                use ActionBlockElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Action(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_action(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = ActionBlockElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Action(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"action",
                                false,
                            )?;
                            match self.handle_action(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::ActionBlockElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ActionBlockElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ActionBlockElementType {
                    local_id: self.local_id,
                    negated: self.negated,
                    width: self.width,
                    height: self.height,
                    execution_order_id: self.execution_order_id,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_in: self.connection_point_in,
                    action: self.action,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct VendorElementElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            width: Option<::core::primitive::f64>,
            height: Option<::core::primitive::f64>,
            execution_order_id: Option<::core::primitive::u64>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            alternative_text: Option<super::FormattedTextType>,
            input_variables: Option<super::BlockInputVariablesElementType>,
            in_out_variables: Option<super::BlockInOutVariablesElementType>,
            output_variables: Option<super::BlockOutputVariablesElementType>,
            add_data: Option<super::AddDataType>,
            state: Box<VendorElementElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum VendorElementElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            AlternativeText(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            InputVariables(
                Option<<super::BlockInputVariablesElementType as WithDeserializer>::Deserializer>,
            ),
            InOutVariables(
                Option<<super::BlockInOutVariablesElementType as WithDeserializer>::Deserializer>,
            ),
            OutputVariables(
                Option<<super::BlockOutputVariablesElementType as WithDeserializer>::Deserializer>,
            ),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl VendorElementElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut execution_order_id: Option<::core::primitive::u64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"executionOrderId")
                    ) {
                        reader.read_attrib(
                            &mut execution_order_id,
                            b"executionOrderId",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    width: width,
                    height: height,
                    execution_order_id: execution_order_id,
                    global_id: global_id,
                    position: None,
                    alternative_text: None,
                    input_variables: None,
                    in_out_variables: None,
                    output_variables: None,
                    add_data: None,
                    state: Box::new(VendorElementElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: VendorElementElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use VendorElementElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::AlternativeText(Some(deserializer)) => {
                        self.store_alternative_text(deserializer.finish(reader)?)?
                    }
                    S::InputVariables(Some(deserializer)) => {
                        self.store_input_variables(deserializer.finish(reader)?)?
                    }
                    S::InOutVariables(Some(deserializer)) => {
                        self.store_in_out_variables(deserializer.finish(reader)?)?
                    }
                    S::OutputVariables(Some(deserializer)) => {
                        self.store_output_variables(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_alternative_text(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.alternative_text.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"alternativeText",
                    )))?;
                }
                self.alternative_text = Some(value);
                Ok(())
            }
            fn store_input_variables(
                &mut self,
                value: super::BlockInputVariablesElementType,
            ) -> Result<(), Error> {
                if self.input_variables.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"inputVariables",
                    )))?;
                }
                self.input_variables = Some(value);
                Ok(())
            }
            fn store_in_out_variables(
                &mut self,
                value: super::BlockInOutVariablesElementType,
            ) -> Result<(), Error> {
                if self.in_out_variables.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"inOutVariables",
                    )))?;
                }
                self.in_out_variables = Some(value);
                Ok(())
            }
            fn store_output_variables(
                &mut self,
                value: super::BlockOutputVariablesElementType,
            ) -> Result<(), Error> {
                if self.output_variables.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"outputVariables",
                    )))?;
                }
                self.output_variables = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<VendorElementElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback.get_or_insert(
                            VendorElementElementTypeDeserializerState::Position(None),
                        );
                        *self.state =
                            VendorElementElementTypeDeserializerState::AlternativeText(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = VendorElementElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state =
                            VendorElementElementTypeDeserializerState::AlternativeText(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VendorElementElementTypeDeserializerState::Position(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    VendorElementElementTypeDeserializerState::AlternativeText(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = VendorElementElementTypeDeserializerState::Position(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_alternative_text<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<VendorElementElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.alternative_text.is_some() {
                        fallback.get_or_insert(
                            VendorElementElementTypeDeserializerState::AlternativeText(None),
                        );
                        *self.state =
                            VendorElementElementTypeDeserializerState::InputVariables(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state =
                            VendorElementElementTypeDeserializerState::AlternativeText(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_alternative_text(data)?;
                        *self.state =
                            VendorElementElementTypeDeserializerState::InputVariables(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VendorElementElementTypeDeserializerState::AlternativeText(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    VendorElementElementTypeDeserializerState::InputVariables(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    VendorElementElementTypeDeserializerState::AlternativeText(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_input_variables<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::BlockInputVariablesElementType>,
                fallback: &mut Option<VendorElementElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        VendorElementElementTypeDeserializerState::InputVariables(None),
                    );
                    *self.state = VendorElementElementTypeDeserializerState::InOutVariables(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_input_variables(data)?;
                        *self.state =
                            VendorElementElementTypeDeserializerState::InOutVariables(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VendorElementElementTypeDeserializerState::InputVariables(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    VendorElementElementTypeDeserializerState::InOutVariables(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    VendorElementElementTypeDeserializerState::InputVariables(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_in_out_variables<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::BlockInOutVariablesElementType>,
                fallback: &mut Option<VendorElementElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        VendorElementElementTypeDeserializerState::InOutVariables(None),
                    );
                    *self.state = VendorElementElementTypeDeserializerState::OutputVariables(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_in_out_variables(data)?;
                        *self.state =
                            VendorElementElementTypeDeserializerState::OutputVariables(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VendorElementElementTypeDeserializerState::InOutVariables(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    VendorElementElementTypeDeserializerState::OutputVariables(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    VendorElementElementTypeDeserializerState::InOutVariables(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_output_variables<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::BlockOutputVariablesElementType>,
                fallback: &mut Option<VendorElementElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        VendorElementElementTypeDeserializerState::OutputVariables(None),
                    );
                    *self.state = VendorElementElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_output_variables(data)?;
                        *self.state = VendorElementElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VendorElementElementTypeDeserializerState::OutputVariables(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    VendorElementElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    VendorElementElementTypeDeserializerState::OutputVariables(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<VendorElementElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.add_data.is_some() {
                        fallback.get_or_insert(VendorElementElementTypeDeserializerState::AddData(
                            None,
                        ));
                        *self.state = VendorElementElementTypeDeserializerState::Done__;
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = VendorElementElementTypeDeserializerState::AddData(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = VendorElementElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    VendorElementElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = VendorElementElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = VendorElementElementTypeDeserializerState::AddData(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::VendorElementElementType>
            for Box<VendorElementElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::VendorElementElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    VendorElementElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::VendorElementElementType>
            where
                R: DeserializeReader,
            {
                use VendorElementElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AlternativeText(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_alternative_text(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::InputVariables(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_input_variables(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::InOutVariables(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_in_out_variables(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::OutputVariables(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_output_variables(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = VendorElementElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AlternativeText(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"alternativeText",
                                true,
                            )?;
                            match self.handle_alternative_text(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::InputVariables(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"inputVariables",
                                true,
                            )?;
                            match self.handle_input_variables(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::InOutVariables(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"inOutVariables",
                                true,
                            )?;
                            match self.handle_in_out_variables(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::OutputVariables(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"outputVariables",
                                false,
                            )?;
                            match self.handle_output_variables(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::VendorElementElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    VendorElementElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::VendorElementElementType {
                    local_id: self.local_id,
                    width: self.width,
                    height: self.height,
                    execution_order_id: self.execution_order_id,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    alternative_text: self
                        .alternative_text
                        .ok_or_else(|| ErrorKind::MissingElement("alternativeText".into()))?,
                    input_variables: self.input_variables,
                    in_out_variables: self.in_out_variables,
                    output_variables: self.output_variables,
                    add_data: self
                        .add_data
                        .ok_or_else(|| ErrorKind::MissingElement("addData".into()))?,
                })
            }
        }
        #[derive(Debug)]
        pub struct BlockElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            width: Option<::core::primitive::f64>,
            height: Option<::core::primitive::f64>,
            type_name: ::std::string::String,
            instance_name: Option<::std::string::String>,
            execution_order_id: Option<::core::primitive::u64>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            input_variables: Option<super::BlockInputVariablesElementType>,
            in_out_variables: Option<super::BlockInOutVariablesElementType>,
            output_variables: Option<super::BlockOutputVariablesElementType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<BlockElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum BlockElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            InputVariables(
                Option<<super::BlockInputVariablesElementType as WithDeserializer>::Deserializer>,
            ),
            InOutVariables(
                Option<<super::BlockInOutVariablesElementType as WithDeserializer>::Deserializer>,
            ),
            OutputVariables(
                Option<<super::BlockOutputVariablesElementType as WithDeserializer>::Deserializer>,
            ),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl BlockElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut type_name: Option<::std::string::String> = None;
                let mut instance_name: Option<::std::string::String> = None;
                let mut execution_order_id: Option<::core::primitive::u64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"typeName")
                    ) {
                        reader.read_attrib(&mut type_name, b"typeName", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"instanceName")
                    ) {
                        reader.read_attrib(&mut instance_name, b"instanceName", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"executionOrderId")
                    ) {
                        reader.read_attrib(
                            &mut execution_order_id,
                            b"executionOrderId",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    width: width,
                    height: height,
                    type_name: type_name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("typeName".into()))
                    })?,
                    instance_name: instance_name,
                    execution_order_id: execution_order_id,
                    global_id: global_id,
                    position: None,
                    input_variables: None,
                    in_out_variables: None,
                    output_variables: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(BlockElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: BlockElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use BlockElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::InputVariables(Some(deserializer)) => {
                        self.store_input_variables(deserializer.finish(reader)?)?
                    }
                    S::InOutVariables(Some(deserializer)) => {
                        self.store_in_out_variables(deserializer.finish(reader)?)?
                    }
                    S::OutputVariables(Some(deserializer)) => {
                        self.store_output_variables(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_input_variables(
                &mut self,
                value: super::BlockInputVariablesElementType,
            ) -> Result<(), Error> {
                if self.input_variables.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"inputVariables",
                    )))?;
                }
                self.input_variables = Some(value);
                Ok(())
            }
            fn store_in_out_variables(
                &mut self,
                value: super::BlockInOutVariablesElementType,
            ) -> Result<(), Error> {
                if self.in_out_variables.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"inOutVariables",
                    )))?;
                }
                self.in_out_variables = Some(value);
                Ok(())
            }
            fn store_output_variables(
                &mut self,
                value: super::BlockOutputVariablesElementType,
            ) -> Result<(), Error> {
                if self.output_variables.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"outputVariables",
                    )))?;
                }
                self.output_variables = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<BlockElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback.get_or_insert(BlockElementTypeDeserializerState::Position(None));
                        *self.state = BlockElementTypeDeserializerState::InputVariables(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = BlockElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state = BlockElementTypeDeserializerState::InputVariables(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    BlockElementTypeDeserializerState::Position(Some(deserializer)),
                                );
                                *self.state =
                                    BlockElementTypeDeserializerState::InputVariables(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    BlockElementTypeDeserializerState::Position(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_input_variables<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::BlockInputVariablesElementType>,
                fallback: &mut Option<BlockElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.input_variables.is_some() {
                        fallback
                            .get_or_insert(BlockElementTypeDeserializerState::InputVariables(None));
                        *self.state = BlockElementTypeDeserializerState::InOutVariables(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = BlockElementTypeDeserializerState::InputVariables(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_input_variables(data)?;
                        *self.state = BlockElementTypeDeserializerState::InOutVariables(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    BlockElementTypeDeserializerState::InputVariables(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    BlockElementTypeDeserializerState::InOutVariables(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = BlockElementTypeDeserializerState::InputVariables(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_in_out_variables<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::BlockInOutVariablesElementType>,
                fallback: &mut Option<BlockElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.in_out_variables.is_some() {
                        fallback
                            .get_or_insert(BlockElementTypeDeserializerState::InOutVariables(None));
                        *self.state = BlockElementTypeDeserializerState::OutputVariables(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = BlockElementTypeDeserializerState::InOutVariables(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_in_out_variables(data)?;
                        *self.state = BlockElementTypeDeserializerState::OutputVariables(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    BlockElementTypeDeserializerState::InOutVariables(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    BlockElementTypeDeserializerState::OutputVariables(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = BlockElementTypeDeserializerState::InOutVariables(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_output_variables<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::BlockOutputVariablesElementType>,
                fallback: &mut Option<BlockElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.output_variables.is_some() {
                        fallback.get_or_insert(BlockElementTypeDeserializerState::OutputVariables(
                            None,
                        ));
                        *self.state = BlockElementTypeDeserializerState::AddData(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = BlockElementTypeDeserializerState::OutputVariables(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_output_variables(data)?;
                        *self.state = BlockElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    BlockElementTypeDeserializerState::OutputVariables(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = BlockElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = BlockElementTypeDeserializerState::OutputVariables(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<BlockElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(BlockElementTypeDeserializerState::AddData(None));
                    *self.state = BlockElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = BlockElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(BlockElementTypeDeserializerState::AddData(
                                    Some(deserializer),
                                ));
                                *self.state =
                                    BlockElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    BlockElementTypeDeserializerState::AddData(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<BlockElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(BlockElementTypeDeserializerState::Documentation(None));
                    *self.state = BlockElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = BlockElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    BlockElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = BlockElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = BlockElementTypeDeserializerState::Documentation(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::BlockElementType> for Box<BlockElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BlockElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    BlockElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BlockElementType>
            where
                R: DeserializeReader,
            {
                use BlockElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::InputVariables(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_input_variables(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::InOutVariables(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_in_out_variables(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::OutputVariables(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_output_variables(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = BlockElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::InputVariables(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"inputVariables",
                                true,
                            )?;
                            match self.handle_input_variables(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::InOutVariables(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"inOutVariables",
                                true,
                            )?;
                            match self.handle_in_out_variables(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::OutputVariables(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"outputVariables",
                                false,
                            )?;
                            match self.handle_output_variables(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::BlockElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    BlockElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::BlockElementType {
                    local_id: self.local_id,
                    width: self.width,
                    height: self.height,
                    type_name: self.type_name,
                    instance_name: self.instance_name,
                    execution_order_id: self.execution_order_id,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    input_variables: self
                        .input_variables
                        .ok_or_else(|| ErrorKind::MissingElement("inputVariables".into()))?,
                    in_out_variables: self
                        .in_out_variables
                        .ok_or_else(|| ErrorKind::MissingElement("inOutVariables".into()))?,
                    output_variables: self
                        .output_variables
                        .ok_or_else(|| ErrorKind::MissingElement("outputVariables".into()))?,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct InVariableElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            execution_order_id: Option<::core::primitive::u64>,
            negated: ::core::primitive::bool,
            edge: super::EdgeModifierType,
            storage: super::StorageModifierType,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_out: Option<super::ConnectionPointOutType>,
            expression: Option<::std::string::String>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<InVariableElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum InVariableElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            ConnectionPointOut(
                Option<<super::ConnectionPointOutType as WithDeserializer>::Deserializer>,
            ),
            Expression(Option<<::std::string::String as WithDeserializer>::Deserializer>),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl InVariableElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut execution_order_id: Option<::core::primitive::u64> = None;
                let mut negated: Option<::core::primitive::bool> = None;
                let mut edge: Option<super::EdgeModifierType> = None;
                let mut storage: Option<super::StorageModifierType> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"executionOrderId")
                    ) {
                        reader.read_attrib(
                            &mut execution_order_id,
                            b"executionOrderId",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"negated")
                    ) {
                        reader.read_attrib(&mut negated, b"negated", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"edge")
                    ) {
                        reader.read_attrib(&mut edge, b"edge", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"storage")
                    ) {
                        reader.read_attrib(&mut storage, b"storage", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    execution_order_id: execution_order_id,
                    negated: negated.unwrap_or_else(super::InVariableElementType::default_negated),
                    edge: edge.unwrap_or_else(super::InVariableElementType::default_edge),
                    storage: storage.unwrap_or_else(super::InVariableElementType::default_storage),
                    global_id: global_id,
                    position: None,
                    connection_point_out: None,
                    expression: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(InVariableElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: InVariableElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use InVariableElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointOut(Some(deserializer)) => {
                        self.store_connection_point_out(deserializer.finish(reader)?)?
                    }
                    S::Expression(Some(deserializer)) => {
                        self.store_expression(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_out(
                &mut self,
                value: super::ConnectionPointOutType,
            ) -> Result<(), Error> {
                if self.connection_point_out.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointOut",
                    )))?;
                }
                self.connection_point_out = Some(value);
                Ok(())
            }
            fn store_expression(&mut self, value: ::std::string::String) -> Result<(), Error> {
                if self.expression.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"expression",
                    )))?;
                }
                self.expression = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<InVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback
                            .get_or_insert(InVariableElementTypeDeserializerState::Position(None));
                        *self.state =
                            InVariableElementTypeDeserializerState::ConnectionPointOut(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = InVariableElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state =
                            InVariableElementTypeDeserializerState::ConnectionPointOut(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    InVariableElementTypeDeserializerState::Position(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    InVariableElementTypeDeserializerState::ConnectionPointOut(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = InVariableElementTypeDeserializerState::Position(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_out<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointOutType>,
                fallback: &mut Option<InVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        InVariableElementTypeDeserializerState::ConnectionPointOut(None),
                    );
                    *self.state = InVariableElementTypeDeserializerState::Expression(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_out(data)?;
                        *self.state = InVariableElementTypeDeserializerState::Expression(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    InVariableElementTypeDeserializerState::ConnectionPointOut(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    InVariableElementTypeDeserializerState::Expression(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    InVariableElementTypeDeserializerState::ConnectionPointOut(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_expression<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, ::std::string::String>,
                fallback: &mut Option<InVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.expression.is_some() {
                        fallback.get_or_insert(InVariableElementTypeDeserializerState::Expression(
                            None,
                        ));
                        *self.state = InVariableElementTypeDeserializerState::AddData(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = InVariableElementTypeDeserializerState::Expression(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_expression(data)?;
                        *self.state = InVariableElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    InVariableElementTypeDeserializerState::Expression(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = InVariableElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = InVariableElementTypeDeserializerState::Expression(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<InVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(InVariableElementTypeDeserializerState::AddData(None));
                    *self.state = InVariableElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = InVariableElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    InVariableElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    InVariableElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = InVariableElementTypeDeserializerState::AddData(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<InVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(InVariableElementTypeDeserializerState::Documentation(None));
                    *self.state = InVariableElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = InVariableElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    InVariableElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = InVariableElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = InVariableElementTypeDeserializerState::Documentation(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::InVariableElementType>
            for Box<InVariableElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::InVariableElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    InVariableElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::InVariableElementType>
            where
                R: DeserializeReader,
            {
                use InVariableElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointOut(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Expression(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_expression(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = InVariableElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointOut(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointOut",
                                false,
                            )?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Expression(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"expression",
                                false,
                            )?;
                            match self.handle_expression(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::InVariableElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    InVariableElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::InVariableElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    execution_order_id: self.execution_order_id,
                    negated: self.negated,
                    edge: self.edge,
                    storage: self.storage,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_out: self.connection_point_out,
                    expression: self
                        .expression
                        .ok_or_else(|| ErrorKind::MissingElement("expression".into()))?,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct OutVariableElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            execution_order_id: Option<::core::primitive::u64>,
            negated: ::core::primitive::bool,
            edge: super::EdgeModifierType,
            storage: super::StorageModifierType,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_in: Option<super::ConnectionPointInType>,
            expression: Option<::std::string::String>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<OutVariableElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum OutVariableElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            ConnectionPointIn(
                Option<<super::ConnectionPointInType as WithDeserializer>::Deserializer>,
            ),
            Expression(Option<<::std::string::String as WithDeserializer>::Deserializer>),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl OutVariableElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut execution_order_id: Option<::core::primitive::u64> = None;
                let mut negated: Option<::core::primitive::bool> = None;
                let mut edge: Option<super::EdgeModifierType> = None;
                let mut storage: Option<super::StorageModifierType> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"executionOrderId")
                    ) {
                        reader.read_attrib(
                            &mut execution_order_id,
                            b"executionOrderId",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"negated")
                    ) {
                        reader.read_attrib(&mut negated, b"negated", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"edge")
                    ) {
                        reader.read_attrib(&mut edge, b"edge", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"storage")
                    ) {
                        reader.read_attrib(&mut storage, b"storage", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    execution_order_id: execution_order_id,
                    negated: negated.unwrap_or_else(super::OutVariableElementType::default_negated),
                    edge: edge.unwrap_or_else(super::OutVariableElementType::default_edge),
                    storage: storage.unwrap_or_else(super::OutVariableElementType::default_storage),
                    global_id: global_id,
                    position: None,
                    connection_point_in: None,
                    expression: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(OutVariableElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: OutVariableElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use OutVariableElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::Expression(Some(deserializer)) => {
                        self.store_expression(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                if self.connection_point_in.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointIn",
                    )))?;
                }
                self.connection_point_in = Some(value);
                Ok(())
            }
            fn store_expression(&mut self, value: ::std::string::String) -> Result<(), Error> {
                if self.expression.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"expression",
                    )))?;
                }
                self.expression = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<OutVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback
                            .get_or_insert(OutVariableElementTypeDeserializerState::Position(None));
                        *self.state =
                            OutVariableElementTypeDeserializerState::ConnectionPointIn(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = OutVariableElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state =
                            OutVariableElementTypeDeserializerState::ConnectionPointIn(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    OutVariableElementTypeDeserializerState::Position(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    OutVariableElementTypeDeserializerState::ConnectionPointIn(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = OutVariableElementTypeDeserializerState::Position(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<OutVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        OutVariableElementTypeDeserializerState::ConnectionPointIn(None),
                    );
                    *self.state = OutVariableElementTypeDeserializerState::Expression(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        *self.state = OutVariableElementTypeDeserializerState::Expression(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    OutVariableElementTypeDeserializerState::ConnectionPointIn(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    OutVariableElementTypeDeserializerState::Expression(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    OutVariableElementTypeDeserializerState::ConnectionPointIn(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_expression<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, ::std::string::String>,
                fallback: &mut Option<OutVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.expression.is_some() {
                        fallback.get_or_insert(
                            OutVariableElementTypeDeserializerState::Expression(None),
                        );
                        *self.state = OutVariableElementTypeDeserializerState::AddData(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = OutVariableElementTypeDeserializerState::Expression(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_expression(data)?;
                        *self.state = OutVariableElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    OutVariableElementTypeDeserializerState::Expression(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    OutVariableElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = OutVariableElementTypeDeserializerState::Expression(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<OutVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(OutVariableElementTypeDeserializerState::AddData(None));
                    *self.state = OutVariableElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = OutVariableElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    OutVariableElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    OutVariableElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = OutVariableElementTypeDeserializerState::AddData(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<OutVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(OutVariableElementTypeDeserializerState::Documentation(
                        None,
                    ));
                    *self.state = OutVariableElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = OutVariableElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    OutVariableElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = OutVariableElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    OutVariableElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    ));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::OutVariableElementType>
            for Box<OutVariableElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::OutVariableElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    OutVariableElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::OutVariableElementType>
            where
                R: DeserializeReader,
            {
                use OutVariableElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Expression(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_expression(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = OutVariableElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Expression(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"expression",
                                false,
                            )?;
                            match self.handle_expression(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::OutVariableElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    OutVariableElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::OutVariableElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    execution_order_id: self.execution_order_id,
                    negated: self.negated,
                    edge: self.edge,
                    storage: self.storage,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_in: self.connection_point_in,
                    expression: self
                        .expression
                        .ok_or_else(|| ErrorKind::MissingElement("expression".into()))?,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct InOutVariableElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            execution_order_id: Option<::core::primitive::u64>,
            negated_in: ::core::primitive::bool,
            edge_in: super::EdgeModifierType,
            storage_in: super::StorageModifierType,
            negated_out: ::core::primitive::bool,
            edge_out: super::EdgeModifierType,
            storage_out: super::StorageModifierType,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_in: Option<super::ConnectionPointInType>,
            connection_point_out: Option<super::ConnectionPointOutType>,
            expression: Option<::std::string::String>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<InOutVariableElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum InOutVariableElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            ConnectionPointIn(
                Option<<super::ConnectionPointInType as WithDeserializer>::Deserializer>,
            ),
            ConnectionPointOut(
                Option<<super::ConnectionPointOutType as WithDeserializer>::Deserializer>,
            ),
            Expression(Option<<::std::string::String as WithDeserializer>::Deserializer>),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl InOutVariableElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut execution_order_id: Option<::core::primitive::u64> = None;
                let mut negated_in: Option<::core::primitive::bool> = None;
                let mut edge_in: Option<super::EdgeModifierType> = None;
                let mut storage_in: Option<super::StorageModifierType> = None;
                let mut negated_out: Option<::core::primitive::bool> = None;
                let mut edge_out: Option<super::EdgeModifierType> = None;
                let mut storage_out: Option<super::StorageModifierType> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"executionOrderId")
                    ) {
                        reader.read_attrib(
                            &mut execution_order_id,
                            b"executionOrderId",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"negatedIn")
                    ) {
                        reader.read_attrib(&mut negated_in, b"negatedIn", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"edgeIn")
                    ) {
                        reader.read_attrib(&mut edge_in, b"edgeIn", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"storageIn")
                    ) {
                        reader.read_attrib(&mut storage_in, b"storageIn", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"negatedOut")
                    ) {
                        reader.read_attrib(&mut negated_out, b"negatedOut", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"edgeOut")
                    ) {
                        reader.read_attrib(&mut edge_out, b"edgeOut", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"storageOut")
                    ) {
                        reader.read_attrib(&mut storage_out, b"storageOut", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    execution_order_id: execution_order_id,
                    negated_in: negated_in
                        .unwrap_or_else(super::InOutVariableElementType::default_negated_in),
                    edge_in: edge_in
                        .unwrap_or_else(super::InOutVariableElementType::default_edge_in),
                    storage_in: storage_in
                        .unwrap_or_else(super::InOutVariableElementType::default_storage_in),
                    negated_out: negated_out
                        .unwrap_or_else(super::InOutVariableElementType::default_negated_out),
                    edge_out: edge_out
                        .unwrap_or_else(super::InOutVariableElementType::default_edge_out),
                    storage_out: storage_out
                        .unwrap_or_else(super::InOutVariableElementType::default_storage_out),
                    global_id: global_id,
                    position: None,
                    connection_point_in: None,
                    connection_point_out: None,
                    expression: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(InOutVariableElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: InOutVariableElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use InOutVariableElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointOut(Some(deserializer)) => {
                        self.store_connection_point_out(deserializer.finish(reader)?)?
                    }
                    S::Expression(Some(deserializer)) => {
                        self.store_expression(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                if self.connection_point_in.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointIn",
                    )))?;
                }
                self.connection_point_in = Some(value);
                Ok(())
            }
            fn store_connection_point_out(
                &mut self,
                value: super::ConnectionPointOutType,
            ) -> Result<(), Error> {
                if self.connection_point_out.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointOut",
                    )))?;
                }
                self.connection_point_out = Some(value);
                Ok(())
            }
            fn store_expression(&mut self, value: ::std::string::String) -> Result<(), Error> {
                if self.expression.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"expression",
                    )))?;
                }
                self.expression = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<InOutVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback.get_or_insert(
                            InOutVariableElementTypeDeserializerState::Position(None),
                        );
                        *self.state =
                            InOutVariableElementTypeDeserializerState::ConnectionPointIn(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = InOutVariableElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state =
                            InOutVariableElementTypeDeserializerState::ConnectionPointIn(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    InOutVariableElementTypeDeserializerState::Position(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    InOutVariableElementTypeDeserializerState::ConnectionPointIn(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = InOutVariableElementTypeDeserializerState::Position(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<InOutVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        InOutVariableElementTypeDeserializerState::ConnectionPointIn(None),
                    );
                    *self.state =
                        InOutVariableElementTypeDeserializerState::ConnectionPointOut(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        *self.state =
                            InOutVariableElementTypeDeserializerState::ConnectionPointOut(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    InOutVariableElementTypeDeserializerState::ConnectionPointIn(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    InOutVariableElementTypeDeserializerState::ConnectionPointOut(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    InOutVariableElementTypeDeserializerState::ConnectionPointIn(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_out<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointOutType>,
                fallback: &mut Option<InOutVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        InOutVariableElementTypeDeserializerState::ConnectionPointOut(None),
                    );
                    *self.state = InOutVariableElementTypeDeserializerState::Expression(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_out(data)?;
                        *self.state = InOutVariableElementTypeDeserializerState::Expression(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    InOutVariableElementTypeDeserializerState::ConnectionPointOut(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    InOutVariableElementTypeDeserializerState::Expression(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    InOutVariableElementTypeDeserializerState::ConnectionPointOut(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_expression<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, ::std::string::String>,
                fallback: &mut Option<InOutVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.expression.is_some() {
                        fallback.get_or_insert(
                            InOutVariableElementTypeDeserializerState::Expression(None),
                        );
                        *self.state = InOutVariableElementTypeDeserializerState::AddData(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = InOutVariableElementTypeDeserializerState::Expression(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_expression(data)?;
                        *self.state = InOutVariableElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    InOutVariableElementTypeDeserializerState::Expression(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    InOutVariableElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = InOutVariableElementTypeDeserializerState::Expression(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<InOutVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(InOutVariableElementTypeDeserializerState::AddData(None));
                    *self.state = InOutVariableElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state =
                            InOutVariableElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    InOutVariableElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    InOutVariableElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = InOutVariableElementTypeDeserializerState::AddData(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<InOutVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        InOutVariableElementTypeDeserializerState::Documentation(None),
                    );
                    *self.state = InOutVariableElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = InOutVariableElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    InOutVariableElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = InOutVariableElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    InOutVariableElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    ));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::InOutVariableElementType>
            for Box<InOutVariableElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::InOutVariableElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    InOutVariableElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::InOutVariableElementType>
            where
                R: DeserializeReader,
            {
                use InOutVariableElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointOut(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Expression(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_expression(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = InOutVariableElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointOut(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointOut",
                                false,
                            )?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Expression(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"expression",
                                false,
                            )?;
                            match self.handle_expression(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::InOutVariableElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    InOutVariableElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::InOutVariableElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    execution_order_id: self.execution_order_id,
                    negated_in: self.negated_in,
                    edge_in: self.edge_in,
                    storage_in: self.storage_in,
                    negated_out: self.negated_out,
                    edge_out: self.edge_out,
                    storage_out: self.storage_out,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_in: self.connection_point_in,
                    connection_point_out: self.connection_point_out,
                    expression: self
                        .expression
                        .ok_or_else(|| ErrorKind::MissingElement("expression".into()))?,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct LabelElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            label: ::std::string::String,
            execution_order_id: Option<::core::primitive::u64>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<LabelElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum LabelElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl LabelElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut label: Option<::std::string::String> = None;
                let mut execution_order_id: Option<::core::primitive::u64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"label")
                    ) {
                        reader.read_attrib(&mut label, b"label", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"executionOrderId")
                    ) {
                        reader.read_attrib(
                            &mut execution_order_id,
                            b"executionOrderId",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    label: label.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("label".into()))
                    })?,
                    execution_order_id: execution_order_id,
                    global_id: global_id,
                    position: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(LabelElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: LabelElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use LabelElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<LabelElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback.get_or_insert(LabelElementTypeDeserializerState::Position(None));
                        *self.state = LabelElementTypeDeserializerState::AddData(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = LabelElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state = LabelElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    LabelElementTypeDeserializerState::Position(Some(deserializer)),
                                );
                                *self.state = LabelElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    LabelElementTypeDeserializerState::Position(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<LabelElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(LabelElementTypeDeserializerState::AddData(None));
                    *self.state = LabelElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = LabelElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(LabelElementTypeDeserializerState::AddData(
                                    Some(deserializer),
                                ));
                                *self.state =
                                    LabelElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    LabelElementTypeDeserializerState::AddData(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<LabelElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(LabelElementTypeDeserializerState::Documentation(None));
                    *self.state = LabelElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = LabelElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    LabelElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = LabelElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = LabelElementTypeDeserializerState::Documentation(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::LabelElementType> for Box<LabelElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::LabelElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    LabelElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::LabelElementType>
            where
                R: DeserializeReader,
            {
                use LabelElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = LabelElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::LabelElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    LabelElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::LabelElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    label: self.label,
                    execution_order_id: self.execution_order_id,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct JumpElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            label: ::std::string::String,
            execution_order_id: Option<::core::primitive::u64>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_in: Option<super::ConnectionPointInType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<JumpElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum JumpElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            ConnectionPointIn(
                Option<<super::ConnectionPointInType as WithDeserializer>::Deserializer>,
            ),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl JumpElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut label: Option<::std::string::String> = None;
                let mut execution_order_id: Option<::core::primitive::u64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"label")
                    ) {
                        reader.read_attrib(&mut label, b"label", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"executionOrderId")
                    ) {
                        reader.read_attrib(
                            &mut execution_order_id,
                            b"executionOrderId",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    label: label.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("label".into()))
                    })?,
                    execution_order_id: execution_order_id,
                    global_id: global_id,
                    position: None,
                    connection_point_in: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(JumpElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: JumpElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use JumpElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                if self.connection_point_in.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointIn",
                    )))?;
                }
                self.connection_point_in = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<JumpElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback.get_or_insert(JumpElementTypeDeserializerState::Position(None));
                        *self.state = JumpElementTypeDeserializerState::ConnectionPointIn(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = JumpElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state = JumpElementTypeDeserializerState::ConnectionPointIn(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(JumpElementTypeDeserializerState::Position(
                                    Some(deserializer),
                                ));
                                *self.state =
                                    JumpElementTypeDeserializerState::ConnectionPointIn(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    JumpElementTypeDeserializerState::Position(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<JumpElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(JumpElementTypeDeserializerState::ConnectionPointIn(None));
                    *self.state = JumpElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        *self.state = JumpElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    JumpElementTypeDeserializerState::ConnectionPointIn(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = JumpElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = JumpElementTypeDeserializerState::ConnectionPointIn(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<JumpElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(JumpElementTypeDeserializerState::AddData(None));
                    *self.state = JumpElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = JumpElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(JumpElementTypeDeserializerState::AddData(
                                    Some(deserializer),
                                ));
                                *self.state = JumpElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    JumpElementTypeDeserializerState::AddData(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<JumpElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(JumpElementTypeDeserializerState::Documentation(None));
                    *self.state = JumpElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = JumpElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    JumpElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = JumpElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = JumpElementTypeDeserializerState::Documentation(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::JumpElementType> for Box<JumpElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::JumpElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    JumpElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::JumpElementType>
            where
                R: DeserializeReader,
            {
                use JumpElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = JumpElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::JumpElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    JumpElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::JumpElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    label: self.label,
                    execution_order_id: self.execution_order_id,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_in: self.connection_point_in,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct ReturnElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            execution_order_id: Option<::core::primitive::u64>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_in: Option<super::ConnectionPointInType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<ReturnElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ReturnElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            ConnectionPointIn(
                Option<<super::ConnectionPointInType as WithDeserializer>::Deserializer>,
            ),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl ReturnElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut execution_order_id: Option<::core::primitive::u64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"executionOrderId")
                    ) {
                        reader.read_attrib(
                            &mut execution_order_id,
                            b"executionOrderId",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    execution_order_id: execution_order_id,
                    global_id: global_id,
                    position: None,
                    connection_point_in: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(ReturnElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ReturnElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ReturnElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                if self.connection_point_in.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointIn",
                    )))?;
                }
                self.connection_point_in = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<ReturnElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback.get_or_insert(ReturnElementTypeDeserializerState::Position(None));
                        *self.state = ReturnElementTypeDeserializerState::ConnectionPointIn(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = ReturnElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state = ReturnElementTypeDeserializerState::ConnectionPointIn(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ReturnElementTypeDeserializerState::Position(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    ReturnElementTypeDeserializerState::ConnectionPointIn(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ReturnElementTypeDeserializerState::Position(Some(
                                    deserializer,
                                ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<ReturnElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(ReturnElementTypeDeserializerState::ConnectionPointIn(None));
                    *self.state = ReturnElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        *self.state = ReturnElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ReturnElementTypeDeserializerState::ConnectionPointIn(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = ReturnElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ReturnElementTypeDeserializerState::ConnectionPointIn(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<ReturnElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(ReturnElementTypeDeserializerState::AddData(None));
                    *self.state = ReturnElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = ReturnElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ReturnElementTypeDeserializerState::AddData(Some(deserializer)),
                                );
                                *self.state =
                                    ReturnElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ReturnElementTypeDeserializerState::AddData(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<ReturnElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(ReturnElementTypeDeserializerState::Documentation(None));
                    *self.state = ReturnElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = ReturnElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ReturnElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = ReturnElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ReturnElementTypeDeserializerState::Documentation(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ReturnElementType> for Box<ReturnElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ReturnElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ReturnElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ReturnElementType>
            where
                R: DeserializeReader,
            {
                use ReturnElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = ReturnElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::ReturnElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ReturnElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ReturnElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    execution_order_id: self.execution_order_id,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_in: self.connection_point_in,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct LeftPowerRailElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            execution_order_id: Option<::core::primitive::u64>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_out: Vec<super::LeftPowerRailConnectionPointOutElementType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<LeftPowerRailElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum LeftPowerRailElementTypeDeserializerState {
            Init__ , Position (Option << super :: PositionType as WithDeserializer > :: Deserializer >) , ConnectionPointOut (Option << super :: LeftPowerRailConnectionPointOutElementType as WithDeserializer > :: Deserializer >) , AddData (Option << super :: AddDataType as WithDeserializer > :: Deserializer >) , Documentation (Option << super :: FormattedTextType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl LeftPowerRailElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut execution_order_id: Option<::core::primitive::u64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"executionOrderId")
                    ) {
                        reader.read_attrib(
                            &mut execution_order_id,
                            b"executionOrderId",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    execution_order_id: execution_order_id,
                    global_id: global_id,
                    position: None,
                    connection_point_out: Vec::new(),
                    add_data: None,
                    documentation: None,
                    state: Box::new(LeftPowerRailElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: LeftPowerRailElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use LeftPowerRailElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointOut(Some(deserializer)) => {
                        self.store_connection_point_out(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_out(
                &mut self,
                value: super::LeftPowerRailConnectionPointOutElementType,
            ) -> Result<(), Error> {
                self.connection_point_out.push(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<LeftPowerRailElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback.get_or_insert(
                            LeftPowerRailElementTypeDeserializerState::Position(None),
                        );
                        *self.state =
                            LeftPowerRailElementTypeDeserializerState::ConnectionPointOut(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = LeftPowerRailElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state =
                            LeftPowerRailElementTypeDeserializerState::ConnectionPointOut(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    LeftPowerRailElementTypeDeserializerState::Position(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    LeftPowerRailElementTypeDeserializerState::ConnectionPointOut(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = LeftPowerRailElementTypeDeserializerState::Position(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_out<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::LeftPowerRailConnectionPointOutElementType>,
                fallback: &mut Option<LeftPowerRailElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        LeftPowerRailElementTypeDeserializerState::ConnectionPointOut(None),
                    );
                    *self.state = LeftPowerRailElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_out(data)?;
                        *self.state =
                            LeftPowerRailElementTypeDeserializerState::ConnectionPointOut(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    LeftPowerRailElementTypeDeserializerState::ConnectionPointOut(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    LeftPowerRailElementTypeDeserializerState::ConnectionPointOut(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    LeftPowerRailElementTypeDeserializerState::ConnectionPointOut(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<LeftPowerRailElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(LeftPowerRailElementTypeDeserializerState::AddData(None));
                    *self.state = LeftPowerRailElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state =
                            LeftPowerRailElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    LeftPowerRailElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    LeftPowerRailElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = LeftPowerRailElementTypeDeserializerState::AddData(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<LeftPowerRailElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        LeftPowerRailElementTypeDeserializerState::Documentation(None),
                    );
                    *self.state = LeftPowerRailElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = LeftPowerRailElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    LeftPowerRailElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = LeftPowerRailElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    LeftPowerRailElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    ));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::LeftPowerRailElementType>
            for Box<LeftPowerRailElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::LeftPowerRailElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    LeftPowerRailElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::LeftPowerRailElementType>
            where
                R: DeserializeReader,
            {
                use LeftPowerRailElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointOut(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = LeftPowerRailElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointOut(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointOut",
                                false,
                            )?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::LeftPowerRailElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    LeftPowerRailElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::LeftPowerRailElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    execution_order_id: self.execution_order_id,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_out: self.connection_point_out,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct RightPowerRailElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            execution_order_id: Option<::core::primitive::u64>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_in: Vec<super::ConnectionPointInType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<RightPowerRailElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum RightPowerRailElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            ConnectionPointIn(
                Option<<super::ConnectionPointInType as WithDeserializer>::Deserializer>,
            ),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl RightPowerRailElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut execution_order_id: Option<::core::primitive::u64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"executionOrderId")
                    ) {
                        reader.read_attrib(
                            &mut execution_order_id,
                            b"executionOrderId",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    execution_order_id: execution_order_id,
                    global_id: global_id,
                    position: None,
                    connection_point_in: Vec::new(),
                    add_data: None,
                    documentation: None,
                    state: Box::new(RightPowerRailElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: RightPowerRailElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use RightPowerRailElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                self.connection_point_in.push(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<RightPowerRailElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback.get_or_insert(
                            RightPowerRailElementTypeDeserializerState::Position(None),
                        );
                        *self.state =
                            RightPowerRailElementTypeDeserializerState::ConnectionPointIn(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = RightPowerRailElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state =
                            RightPowerRailElementTypeDeserializerState::ConnectionPointIn(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    RightPowerRailElementTypeDeserializerState::Position(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    RightPowerRailElementTypeDeserializerState::ConnectionPointIn(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = RightPowerRailElementTypeDeserializerState::Position(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<RightPowerRailElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        RightPowerRailElementTypeDeserializerState::ConnectionPointIn(None),
                    );
                    *self.state = RightPowerRailElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        *self.state =
                            RightPowerRailElementTypeDeserializerState::ConnectionPointIn(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    RightPowerRailElementTypeDeserializerState::ConnectionPointIn(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    RightPowerRailElementTypeDeserializerState::ConnectionPointIn(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    RightPowerRailElementTypeDeserializerState::ConnectionPointIn(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<RightPowerRailElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(RightPowerRailElementTypeDeserializerState::AddData(None));
                    *self.state = RightPowerRailElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state =
                            RightPowerRailElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    RightPowerRailElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    RightPowerRailElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = RightPowerRailElementTypeDeserializerState::AddData(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<RightPowerRailElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        RightPowerRailElementTypeDeserializerState::Documentation(None),
                    );
                    *self.state = RightPowerRailElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = RightPowerRailElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    RightPowerRailElementTypeDeserializerState::Documentation(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state = RightPowerRailElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    RightPowerRailElementTypeDeserializerState::Documentation(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::RightPowerRailElementType>
            for Box<RightPowerRailElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::RightPowerRailElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    RightPowerRailElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::RightPowerRailElementType>
            where
                R: DeserializeReader,
            {
                use RightPowerRailElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                RightPowerRailElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::RightPowerRailElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    RightPowerRailElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::RightPowerRailElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    execution_order_id: self.execution_order_id,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_in: self.connection_point_in,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct CoilElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            execution_order_id: Option<::core::primitive::u64>,
            negated: ::core::primitive::bool,
            edge: super::EdgeModifierType,
            storage: super::StorageModifierType,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_in: Option<super::ConnectionPointInType>,
            connection_point_out: Option<super::ConnectionPointOutType>,
            variable: Option<::std::string::String>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<CoilElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum CoilElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            ConnectionPointIn(
                Option<<super::ConnectionPointInType as WithDeserializer>::Deserializer>,
            ),
            ConnectionPointOut(
                Option<<super::ConnectionPointOutType as WithDeserializer>::Deserializer>,
            ),
            Variable(Option<<::std::string::String as WithDeserializer>::Deserializer>),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl CoilElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut execution_order_id: Option<::core::primitive::u64> = None;
                let mut negated: Option<::core::primitive::bool> = None;
                let mut edge: Option<super::EdgeModifierType> = None;
                let mut storage: Option<super::StorageModifierType> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"executionOrderId")
                    ) {
                        reader.read_attrib(
                            &mut execution_order_id,
                            b"executionOrderId",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"negated")
                    ) {
                        reader.read_attrib(&mut negated, b"negated", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"edge")
                    ) {
                        reader.read_attrib(&mut edge, b"edge", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"storage")
                    ) {
                        reader.read_attrib(&mut storage, b"storage", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    execution_order_id: execution_order_id,
                    negated: negated.unwrap_or_else(super::CoilElementType::default_negated),
                    edge: edge.unwrap_or_else(super::CoilElementType::default_edge),
                    storage: storage.unwrap_or_else(super::CoilElementType::default_storage),
                    global_id: global_id,
                    position: None,
                    connection_point_in: None,
                    connection_point_out: None,
                    variable: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(CoilElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: CoilElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use CoilElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointOut(Some(deserializer)) => {
                        self.store_connection_point_out(deserializer.finish(reader)?)?
                    }
                    S::Variable(Some(deserializer)) => {
                        self.store_variable(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                if self.connection_point_in.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointIn",
                    )))?;
                }
                self.connection_point_in = Some(value);
                Ok(())
            }
            fn store_connection_point_out(
                &mut self,
                value: super::ConnectionPointOutType,
            ) -> Result<(), Error> {
                if self.connection_point_out.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointOut",
                    )))?;
                }
                self.connection_point_out = Some(value);
                Ok(())
            }
            fn store_variable(&mut self, value: ::std::string::String) -> Result<(), Error> {
                if self.variable.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"variable",
                    )))?;
                }
                self.variable = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<CoilElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback.get_or_insert(CoilElementTypeDeserializerState::Position(None));
                        *self.state = CoilElementTypeDeserializerState::ConnectionPointIn(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = CoilElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state = CoilElementTypeDeserializerState::ConnectionPointIn(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(CoilElementTypeDeserializerState::Position(
                                    Some(deserializer),
                                ));
                                *self.state =
                                    CoilElementTypeDeserializerState::ConnectionPointIn(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    CoilElementTypeDeserializerState::Position(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<CoilElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(CoilElementTypeDeserializerState::ConnectionPointIn(None));
                    *self.state = CoilElementTypeDeserializerState::ConnectionPointOut(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        *self.state = CoilElementTypeDeserializerState::ConnectionPointOut(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    CoilElementTypeDeserializerState::ConnectionPointIn(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    CoilElementTypeDeserializerState::ConnectionPointOut(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = CoilElementTypeDeserializerState::ConnectionPointIn(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_out<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointOutType>,
                fallback: &mut Option<CoilElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(CoilElementTypeDeserializerState::ConnectionPointOut(None));
                    *self.state = CoilElementTypeDeserializerState::Variable(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_out(data)?;
                        *self.state = CoilElementTypeDeserializerState::Variable(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    CoilElementTypeDeserializerState::ConnectionPointOut(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = CoilElementTypeDeserializerState::Variable(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = CoilElementTypeDeserializerState::ConnectionPointOut(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_variable<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, ::std::string::String>,
                fallback: &mut Option<CoilElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.variable.is_some() {
                        fallback.get_or_insert(CoilElementTypeDeserializerState::Variable(None));
                        *self.state = CoilElementTypeDeserializerState::AddData(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = CoilElementTypeDeserializerState::Variable(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_variable(data)?;
                        *self.state = CoilElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(CoilElementTypeDeserializerState::Variable(
                                    Some(deserializer),
                                ));
                                *self.state = CoilElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    CoilElementTypeDeserializerState::Variable(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<CoilElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(CoilElementTypeDeserializerState::AddData(None));
                    *self.state = CoilElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = CoilElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(CoilElementTypeDeserializerState::AddData(
                                    Some(deserializer),
                                ));
                                *self.state = CoilElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    CoilElementTypeDeserializerState::AddData(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<CoilElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(CoilElementTypeDeserializerState::Documentation(None));
                    *self.state = CoilElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = CoilElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    CoilElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = CoilElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = CoilElementTypeDeserializerState::Documentation(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::CoilElementType> for Box<CoilElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::CoilElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    CoilElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::CoilElementType>
            where
                R: DeserializeReader,
            {
                use CoilElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointOut(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Variable(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = CoilElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointOut(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointOut",
                                false,
                            )?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Variable(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"variable",
                                false,
                            )?;
                            match self.handle_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::CoilElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    CoilElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::CoilElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    execution_order_id: self.execution_order_id,
                    negated: self.negated,
                    edge: self.edge,
                    storage: self.storage,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_in: self.connection_point_in,
                    connection_point_out: self.connection_point_out,
                    variable: self
                        .variable
                        .ok_or_else(|| ErrorKind::MissingElement("variable".into()))?,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct StepElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            name: ::std::string::String,
            initial_step: ::core::primitive::bool,
            negated: ::core::primitive::bool,
            execution_order_id: Option<::core::primitive::u64>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_in: Option<super::ConnectionPointInType>,
            connection_point_out: Option<super::LeftPowerRailConnectionPointOutElementType>,
            connection_point_out_action: Option<super::LeftPowerRailConnectionPointOutElementType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<StepElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum StepElementTypeDeserializerState {
            Init__ , Position (Option << super :: PositionType as WithDeserializer > :: Deserializer >) , ConnectionPointIn (Option << super :: ConnectionPointInType as WithDeserializer > :: Deserializer >) , ConnectionPointOut (Option << super :: LeftPowerRailConnectionPointOutElementType as WithDeserializer > :: Deserializer >) , ConnectionPointOutAction (Option << super :: LeftPowerRailConnectionPointOutElementType as WithDeserializer > :: Deserializer >) , AddData (Option << super :: AddDataType as WithDeserializer > :: Deserializer >) , Documentation (Option << super :: FormattedTextType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl StepElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut name: Option<::std::string::String> = None;
                let mut initial_step: Option<::core::primitive::bool> = None;
                let mut negated: Option<::core::primitive::bool> = None;
                let mut execution_order_id: Option<::core::primitive::u64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"initialStep")
                    ) {
                        reader.read_attrib(&mut initial_step, b"initialStep", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"negated")
                    ) {
                        reader.read_attrib(&mut negated, b"negated", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"executionOrderId")
                    ) {
                        reader.read_attrib(
                            &mut execution_order_id,
                            b"executionOrderId",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    name: name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("name".into()))
                    })?,
                    initial_step: initial_step
                        .unwrap_or_else(super::StepElementType::default_initial_step),
                    negated: negated.unwrap_or_else(super::StepElementType::default_negated),
                    execution_order_id: execution_order_id,
                    global_id: global_id,
                    position: None,
                    connection_point_in: None,
                    connection_point_out: None,
                    connection_point_out_action: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(StepElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: StepElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use StepElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointOut(Some(deserializer)) => {
                        self.store_connection_point_out(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointOutAction(Some(deserializer)) => {
                        self.store_connection_point_out_action(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                if self.connection_point_in.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointIn",
                    )))?;
                }
                self.connection_point_in = Some(value);
                Ok(())
            }
            fn store_connection_point_out(
                &mut self,
                value: super::LeftPowerRailConnectionPointOutElementType,
            ) -> Result<(), Error> {
                if self.connection_point_out.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointOut",
                    )))?;
                }
                self.connection_point_out = Some(value);
                Ok(())
            }
            fn store_connection_point_out_action(
                &mut self,
                value: super::LeftPowerRailConnectionPointOutElementType,
            ) -> Result<(), Error> {
                if self.connection_point_out_action.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointOutAction",
                    )))?;
                }
                self.connection_point_out_action = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<StepElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback.get_or_insert(StepElementTypeDeserializerState::Position(None));
                        *self.state = StepElementTypeDeserializerState::ConnectionPointIn(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = StepElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state = StepElementTypeDeserializerState::ConnectionPointIn(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(StepElementTypeDeserializerState::Position(
                                    Some(deserializer),
                                ));
                                *self.state =
                                    StepElementTypeDeserializerState::ConnectionPointIn(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    StepElementTypeDeserializerState::Position(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<StepElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(StepElementTypeDeserializerState::ConnectionPointIn(None));
                    *self.state = StepElementTypeDeserializerState::ConnectionPointOut(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        *self.state = StepElementTypeDeserializerState::ConnectionPointOut(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    StepElementTypeDeserializerState::ConnectionPointIn(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    StepElementTypeDeserializerState::ConnectionPointOut(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = StepElementTypeDeserializerState::ConnectionPointIn(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_out<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::LeftPowerRailConnectionPointOutElementType>,
                fallback: &mut Option<StepElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(StepElementTypeDeserializerState::ConnectionPointOut(None));
                    *self.state = StepElementTypeDeserializerState::ConnectionPointOutAction(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_out(data)?;
                        *self.state =
                            StepElementTypeDeserializerState::ConnectionPointOutAction(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    StepElementTypeDeserializerState::ConnectionPointOut(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    StepElementTypeDeserializerState::ConnectionPointOutAction(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = StepElementTypeDeserializerState::ConnectionPointOut(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_out_action<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::LeftPowerRailConnectionPointOutElementType>,
                fallback: &mut Option<StepElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        StepElementTypeDeserializerState::ConnectionPointOutAction(None),
                    );
                    *self.state = StepElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_out_action(data)?;
                        *self.state = StepElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    StepElementTypeDeserializerState::ConnectionPointOutAction(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state = StepElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    StepElementTypeDeserializerState::ConnectionPointOutAction(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<StepElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(StepElementTypeDeserializerState::AddData(None));
                    *self.state = StepElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = StepElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(StepElementTypeDeserializerState::AddData(
                                    Some(deserializer),
                                ));
                                *self.state = StepElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    StepElementTypeDeserializerState::AddData(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<StepElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(StepElementTypeDeserializerState::Documentation(None));
                    *self.state = StepElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = StepElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    StepElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = StepElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = StepElementTypeDeserializerState::Documentation(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::StepElementType> for Box<StepElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::StepElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    StepElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::StepElementType>
            where
                R: DeserializeReader,
            {
                use StepElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointOut(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointOutAction(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_out_action(
                                reader,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = StepElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointOut(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointOut",
                                false,
                            )?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointOutAction(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointOutAction",
                                false,
                            )?;
                            match self.handle_connection_point_out_action(
                                reader,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::StepElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    StepElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::StepElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    name: self.name,
                    initial_step: self.initial_step,
                    negated: self.negated,
                    execution_order_id: self.execution_order_id,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_in: self.connection_point_in,
                    connection_point_out: self.connection_point_out,
                    connection_point_out_action: self.connection_point_out_action,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct MacroStepElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            name: Option<::std::string::String>,
            execution_order_id: Option<::core::primitive::u64>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_in: Option<super::ConnectionPointInType>,
            connection_point_out: Option<super::ConnectionPointOutType>,
            body: Option<super::BodyType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<MacroStepElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum MacroStepElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            ConnectionPointIn(
                Option<<super::ConnectionPointInType as WithDeserializer>::Deserializer>,
            ),
            ConnectionPointOut(
                Option<<super::ConnectionPointOutType as WithDeserializer>::Deserializer>,
            ),
            Body(Option<<super::BodyType as WithDeserializer>::Deserializer>),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl MacroStepElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut name: Option<::std::string::String> = None;
                let mut execution_order_id: Option<::core::primitive::u64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"executionOrderId")
                    ) {
                        reader.read_attrib(
                            &mut execution_order_id,
                            b"executionOrderId",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    name: name,
                    execution_order_id: execution_order_id,
                    global_id: global_id,
                    position: None,
                    connection_point_in: None,
                    connection_point_out: None,
                    body: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(MacroStepElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: MacroStepElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use MacroStepElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointOut(Some(deserializer)) => {
                        self.store_connection_point_out(deserializer.finish(reader)?)?
                    }
                    S::Body(Some(deserializer)) => self.store_body(deserializer.finish(reader)?)?,
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                if self.connection_point_in.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointIn",
                    )))?;
                }
                self.connection_point_in = Some(value);
                Ok(())
            }
            fn store_connection_point_out(
                &mut self,
                value: super::ConnectionPointOutType,
            ) -> Result<(), Error> {
                if self.connection_point_out.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointOut",
                    )))?;
                }
                self.connection_point_out = Some(value);
                Ok(())
            }
            fn store_body(&mut self, value: super::BodyType) -> Result<(), Error> {
                if self.body.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"body")))?;
                }
                self.body = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<MacroStepElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback
                            .get_or_insert(MacroStepElementTypeDeserializerState::Position(None));
                        *self.state =
                            MacroStepElementTypeDeserializerState::ConnectionPointIn(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = MacroStepElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state =
                            MacroStepElementTypeDeserializerState::ConnectionPointIn(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    MacroStepElementTypeDeserializerState::Position(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    MacroStepElementTypeDeserializerState::ConnectionPointIn(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = MacroStepElementTypeDeserializerState::Position(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<MacroStepElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        MacroStepElementTypeDeserializerState::ConnectionPointIn(None),
                    );
                    *self.state = MacroStepElementTypeDeserializerState::ConnectionPointOut(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        *self.state =
                            MacroStepElementTypeDeserializerState::ConnectionPointOut(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    MacroStepElementTypeDeserializerState::ConnectionPointIn(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    MacroStepElementTypeDeserializerState::ConnectionPointOut(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    MacroStepElementTypeDeserializerState::ConnectionPointIn(Some(
                                        deserializer,
                                    ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_out<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointOutType>,
                fallback: &mut Option<MacroStepElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        MacroStepElementTypeDeserializerState::ConnectionPointOut(None),
                    );
                    *self.state = MacroStepElementTypeDeserializerState::Body(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_out(data)?;
                        *self.state = MacroStepElementTypeDeserializerState::Body(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    MacroStepElementTypeDeserializerState::ConnectionPointOut(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state = MacroStepElementTypeDeserializerState::Body(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    MacroStepElementTypeDeserializerState::ConnectionPointOut(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_body<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::BodyType>,
                fallback: &mut Option<MacroStepElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(MacroStepElementTypeDeserializerState::Body(None));
                    *self.state = MacroStepElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_body(data)?;
                        *self.state = MacroStepElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    MacroStepElementTypeDeserializerState::Body(Some(deserializer)),
                                );
                                *self.state = MacroStepElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    MacroStepElementTypeDeserializerState::Body(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<MacroStepElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(MacroStepElementTypeDeserializerState::AddData(None));
                    *self.state = MacroStepElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = MacroStepElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    MacroStepElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    MacroStepElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = MacroStepElementTypeDeserializerState::AddData(Some(
                                    deserializer,
                                ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<MacroStepElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(MacroStepElementTypeDeserializerState::Documentation(None));
                    *self.state = MacroStepElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = MacroStepElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    MacroStepElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = MacroStepElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = MacroStepElementTypeDeserializerState::Documentation(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::MacroStepElementType> for Box<MacroStepElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::MacroStepElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    MacroStepElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::MacroStepElementType>
            where
                R: DeserializeReader,
            {
                use MacroStepElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointOut(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Body(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_body(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = MacroStepElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointOut(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointOut",
                                false,
                            )?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Body(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"body",
                                true,
                            )?;
                            match self.handle_body(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::MacroStepElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    MacroStepElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::MacroStepElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    name: self.name,
                    execution_order_id: self.execution_order_id,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_in: self.connection_point_in,
                    connection_point_out: self.connection_point_out,
                    body: self.body,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct JumpStepElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            target_name: ::std::string::String,
            execution_order_id: Option<::core::primitive::u64>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_in: Option<super::ConnectionPointInType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<JumpStepElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum JumpStepElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            ConnectionPointIn(
                Option<<super::ConnectionPointInType as WithDeserializer>::Deserializer>,
            ),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl JumpStepElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut target_name: Option<::std::string::String> = None;
                let mut execution_order_id: Option<::core::primitive::u64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"targetName")
                    ) {
                        reader.read_attrib(&mut target_name, b"targetName", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"executionOrderId")
                    ) {
                        reader.read_attrib(
                            &mut execution_order_id,
                            b"executionOrderId",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    target_name: target_name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("targetName".into()))
                    })?,
                    execution_order_id: execution_order_id,
                    global_id: global_id,
                    position: None,
                    connection_point_in: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(JumpStepElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: JumpStepElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use JumpStepElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                if self.connection_point_in.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointIn",
                    )))?;
                }
                self.connection_point_in = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<JumpStepElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback
                            .get_or_insert(JumpStepElementTypeDeserializerState::Position(None));
                        *self.state = JumpStepElementTypeDeserializerState::ConnectionPointIn(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = JumpStepElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state = JumpStepElementTypeDeserializerState::ConnectionPointIn(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    JumpStepElementTypeDeserializerState::Position(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    JumpStepElementTypeDeserializerState::ConnectionPointIn(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = JumpStepElementTypeDeserializerState::Position(Some(
                                    deserializer,
                                ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<JumpStepElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        JumpStepElementTypeDeserializerState::ConnectionPointIn(None),
                    );
                    *self.state = JumpStepElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        *self.state = JumpStepElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    JumpStepElementTypeDeserializerState::ConnectionPointIn(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = JumpStepElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    JumpStepElementTypeDeserializerState::ConnectionPointIn(Some(
                                        deserializer,
                                    ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<JumpStepElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(JumpStepElementTypeDeserializerState::AddData(None));
                    *self.state = JumpStepElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = JumpStepElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    JumpStepElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    JumpStepElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = JumpStepElementTypeDeserializerState::AddData(Some(
                                    deserializer,
                                ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<JumpStepElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(JumpStepElementTypeDeserializerState::Documentation(None));
                    *self.state = JumpStepElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = JumpStepElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    JumpStepElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = JumpStepElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = JumpStepElementTypeDeserializerState::Documentation(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::JumpStepElementType> for Box<JumpStepElementTypeDeserializer> {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::JumpStepElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    JumpStepElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::JumpStepElementType>
            where
                R: DeserializeReader,
            {
                use JumpStepElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = JumpStepElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::JumpStepElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    JumpStepElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::JumpStepElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    target_name: self.target_name,
                    execution_order_id: self.execution_order_id,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_in: self.connection_point_in,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct TransitionElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            priority: Option<::core::primitive::u64>,
            execution_order_id: Option<::core::primitive::u64>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_in: Option<super::ConnectionPointInType>,
            connection_point_out: Option<super::ConnectionPointOutType>,
            condition: Option<super::TransitionConditionElementType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<TransitionElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum TransitionElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            ConnectionPointIn(
                Option<<super::ConnectionPointInType as WithDeserializer>::Deserializer>,
            ),
            ConnectionPointOut(
                Option<<super::ConnectionPointOutType as WithDeserializer>::Deserializer>,
            ),
            Condition(
                Option<<super::TransitionConditionElementType as WithDeserializer>::Deserializer>,
            ),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl TransitionElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut priority: Option<::core::primitive::u64> = None;
                let mut execution_order_id: Option<::core::primitive::u64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"priority")
                    ) {
                        reader.read_attrib(&mut priority, b"priority", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"executionOrderId")
                    ) {
                        reader.read_attrib(
                            &mut execution_order_id,
                            b"executionOrderId",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    priority: priority,
                    execution_order_id: execution_order_id,
                    global_id: global_id,
                    position: None,
                    connection_point_in: None,
                    connection_point_out: None,
                    condition: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(TransitionElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: TransitionElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use TransitionElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointOut(Some(deserializer)) => {
                        self.store_connection_point_out(deserializer.finish(reader)?)?
                    }
                    S::Condition(Some(deserializer)) => {
                        self.store_condition(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                if self.connection_point_in.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointIn",
                    )))?;
                }
                self.connection_point_in = Some(value);
                Ok(())
            }
            fn store_connection_point_out(
                &mut self,
                value: super::ConnectionPointOutType,
            ) -> Result<(), Error> {
                if self.connection_point_out.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointOut",
                    )))?;
                }
                self.connection_point_out = Some(value);
                Ok(())
            }
            fn store_condition(
                &mut self,
                value: super::TransitionConditionElementType,
            ) -> Result<(), Error> {
                if self.condition.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"condition",
                    )))?;
                }
                self.condition = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<TransitionElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback
                            .get_or_insert(TransitionElementTypeDeserializerState::Position(None));
                        *self.state =
                            TransitionElementTypeDeserializerState::ConnectionPointIn(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = TransitionElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state =
                            TransitionElementTypeDeserializerState::ConnectionPointIn(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    TransitionElementTypeDeserializerState::Position(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    TransitionElementTypeDeserializerState::ConnectionPointIn(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = TransitionElementTypeDeserializerState::Position(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<TransitionElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        TransitionElementTypeDeserializerState::ConnectionPointIn(None),
                    );
                    *self.state = TransitionElementTypeDeserializerState::ConnectionPointOut(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        *self.state =
                            TransitionElementTypeDeserializerState::ConnectionPointOut(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    TransitionElementTypeDeserializerState::ConnectionPointIn(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    TransitionElementTypeDeserializerState::ConnectionPointOut(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    TransitionElementTypeDeserializerState::ConnectionPointIn(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_out<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointOutType>,
                fallback: &mut Option<TransitionElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        TransitionElementTypeDeserializerState::ConnectionPointOut(None),
                    );
                    *self.state = TransitionElementTypeDeserializerState::Condition(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_out(data)?;
                        *self.state = TransitionElementTypeDeserializerState::Condition(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    TransitionElementTypeDeserializerState::ConnectionPointOut(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    TransitionElementTypeDeserializerState::Condition(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    TransitionElementTypeDeserializerState::ConnectionPointOut(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_condition<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::TransitionConditionElementType>,
                fallback: &mut Option<TransitionElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(TransitionElementTypeDeserializerState::Condition(None));
                    *self.state = TransitionElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_condition(data)?;
                        *self.state = TransitionElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    TransitionElementTypeDeserializerState::Condition(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = TransitionElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = TransitionElementTypeDeserializerState::Condition(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<TransitionElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(TransitionElementTypeDeserializerState::AddData(None));
                    *self.state = TransitionElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state = TransitionElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    TransitionElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    TransitionElementTypeDeserializerState::Documentation(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = TransitionElementTypeDeserializerState::AddData(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<TransitionElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(TransitionElementTypeDeserializerState::Documentation(None));
                    *self.state = TransitionElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = TransitionElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    TransitionElementTypeDeserializerState::Documentation(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = TransitionElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = TransitionElementTypeDeserializerState::Documentation(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::TransitionElementType>
            for Box<TransitionElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::TransitionElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    TransitionElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::TransitionElementType>
            where
                R: DeserializeReader,
            {
                use TransitionElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointOut(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Condition(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_condition(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = TransitionElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointOut(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointOut",
                                false,
                            )?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Condition(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"condition",
                                true,
                            )?;
                            match self.handle_condition(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::TransitionElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    TransitionElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::TransitionElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    priority: self.priority,
                    execution_order_id: self.execution_order_id,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_in: self.connection_point_in,
                    connection_point_out: self.connection_point_out,
                    condition: self.condition,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct SelectionDivergenceElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_in: Option<super::ConnectionPointInType>,
            connection_point_out: Vec<super::LeftPowerRailConnectionPointOutElementType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<SelectionDivergenceElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum SelectionDivergenceElementTypeDeserializerState {
            Init__ , Position (Option << super :: PositionType as WithDeserializer > :: Deserializer >) , ConnectionPointIn (Option << super :: ConnectionPointInType as WithDeserializer > :: Deserializer >) , ConnectionPointOut (Option << super :: LeftPowerRailConnectionPointOutElementType as WithDeserializer > :: Deserializer >) , AddData (Option << super :: AddDataType as WithDeserializer > :: Deserializer >) , Documentation (Option << super :: FormattedTextType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl SelectionDivergenceElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    global_id: global_id,
                    position: None,
                    connection_point_in: None,
                    connection_point_out: Vec::new(),
                    add_data: None,
                    documentation: None,
                    state: Box::new(SelectionDivergenceElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: SelectionDivergenceElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use SelectionDivergenceElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointOut(Some(deserializer)) => {
                        self.store_connection_point_out(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                if self.connection_point_in.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointIn",
                    )))?;
                }
                self.connection_point_in = Some(value);
                Ok(())
            }
            fn store_connection_point_out(
                &mut self,
                value: super::LeftPowerRailConnectionPointOutElementType,
            ) -> Result<(), Error> {
                self.connection_point_out.push(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<SelectionDivergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback.get_or_insert(
                            SelectionDivergenceElementTypeDeserializerState::Position(None),
                        );
                        *self.state =
                            SelectionDivergenceElementTypeDeserializerState::ConnectionPointIn(
                                None,
                            );
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state =
                            SelectionDivergenceElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state =
                            SelectionDivergenceElementTypeDeserializerState::ConnectionPointIn(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    SelectionDivergenceElementTypeDeserializerState::Position(
                                        Some(deserializer),
                                    ),
                                );
                                * self . state = SelectionDivergenceElementTypeDeserializerState :: ConnectionPointIn (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    SelectionDivergenceElementTypeDeserializerState::Position(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<SelectionDivergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        SelectionDivergenceElementTypeDeserializerState::ConnectionPointIn(None),
                    );
                    *self.state =
                        SelectionDivergenceElementTypeDeserializerState::ConnectionPointOut(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        *self.state =
                            SelectionDivergenceElementTypeDeserializerState::ConnectionPointOut(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (SelectionDivergenceElementTypeDeserializerState :: ConnectionPointIn (Some (deserializer))) ;
                                * self . state = SelectionDivergenceElementTypeDeserializerState :: ConnectionPointOut (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = SelectionDivergenceElementTypeDeserializerState :: ConnectionPointIn (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_out<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::LeftPowerRailConnectionPointOutElementType>,
                fallback: &mut Option<SelectionDivergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        SelectionDivergenceElementTypeDeserializerState::ConnectionPointOut(None),
                    );
                    *self.state = SelectionDivergenceElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_out(data)?;
                        *self.state =
                            SelectionDivergenceElementTypeDeserializerState::ConnectionPointOut(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (SelectionDivergenceElementTypeDeserializerState :: ConnectionPointOut (Some (deserializer))) ;
                                * self . state = SelectionDivergenceElementTypeDeserializerState :: ConnectionPointOut (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = SelectionDivergenceElementTypeDeserializerState :: ConnectionPointOut (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<SelectionDivergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        SelectionDivergenceElementTypeDeserializerState::AddData(None),
                    );
                    *self.state =
                        SelectionDivergenceElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state =
                            SelectionDivergenceElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    SelectionDivergenceElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    SelectionDivergenceElementTypeDeserializerState::Documentation(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    SelectionDivergenceElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<SelectionDivergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        SelectionDivergenceElementTypeDeserializerState::Documentation(None),
                    );
                    *self.state = SelectionDivergenceElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = SelectionDivergenceElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    SelectionDivergenceElementTypeDeserializerState::Documentation(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    SelectionDivergenceElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    SelectionDivergenceElementTypeDeserializerState::Documentation(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::SelectionDivergenceElementType>
            for Box<SelectionDivergenceElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::SelectionDivergenceElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    SelectionDivergenceElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::SelectionDivergenceElementType>
            where
                R: DeserializeReader,
            {
                use SelectionDivergenceElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointOut(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                SelectionDivergenceElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointOut(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointOut",
                                false,
                            )?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::SelectionDivergenceElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    SelectionDivergenceElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::SelectionDivergenceElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_in: self.connection_point_in,
                    connection_point_out: self.connection_point_out,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct SelectionConvergenceElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_in: Vec<super::SelectionConvergenceConnectionPointInElementType>,
            connection_point_out: Option<super::ConnectionPointOutType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<SelectionConvergenceElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum SelectionConvergenceElementTypeDeserializerState {
            Init__ , Position (Option << super :: PositionType as WithDeserializer > :: Deserializer >) , ConnectionPointIn (Option << super :: SelectionConvergenceConnectionPointInElementType as WithDeserializer > :: Deserializer >) , ConnectionPointOut (Option << super :: ConnectionPointOutType as WithDeserializer > :: Deserializer >) , AddData (Option << super :: AddDataType as WithDeserializer > :: Deserializer >) , Documentation (Option << super :: FormattedTextType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl SelectionConvergenceElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    global_id: global_id,
                    position: None,
                    connection_point_in: Vec::new(),
                    connection_point_out: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(SelectionConvergenceElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: SelectionConvergenceElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use SelectionConvergenceElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointOut(Some(deserializer)) => {
                        self.store_connection_point_out(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::SelectionConvergenceConnectionPointInElementType,
            ) -> Result<(), Error> {
                self.connection_point_in.push(value);
                Ok(())
            }
            fn store_connection_point_out(
                &mut self,
                value: super::ConnectionPointOutType,
            ) -> Result<(), Error> {
                if self.connection_point_out.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointOut",
                    )))?;
                }
                self.connection_point_out = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<SelectionConvergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback.get_or_insert(
                            SelectionConvergenceElementTypeDeserializerState::Position(None),
                        );
                        *self.state =
                            SelectionConvergenceElementTypeDeserializerState::ConnectionPointIn(
                                None,
                            );
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state =
                            SelectionConvergenceElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state =
                            SelectionConvergenceElementTypeDeserializerState::ConnectionPointIn(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    SelectionConvergenceElementTypeDeserializerState::Position(
                                        Some(deserializer),
                                    ),
                                );
                                * self . state = SelectionConvergenceElementTypeDeserializerState :: ConnectionPointIn (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    SelectionConvergenceElementTypeDeserializerState::Position(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<
                    'de,
                    super::SelectionConvergenceConnectionPointInElementType,
                >,
                fallback: &mut Option<SelectionConvergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        SelectionConvergenceElementTypeDeserializerState::ConnectionPointIn(None),
                    );
                    *self.state =
                        SelectionConvergenceElementTypeDeserializerState::ConnectionPointOut(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        *self.state =
                            SelectionConvergenceElementTypeDeserializerState::ConnectionPointIn(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (SelectionConvergenceElementTypeDeserializerState :: ConnectionPointIn (Some (deserializer))) ;
                                * self . state = SelectionConvergenceElementTypeDeserializerState :: ConnectionPointIn (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = SelectionConvergenceElementTypeDeserializerState :: ConnectionPointIn (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_out<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointOutType>,
                fallback: &mut Option<SelectionConvergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        SelectionConvergenceElementTypeDeserializerState::ConnectionPointOut(None),
                    );
                    *self.state = SelectionConvergenceElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_out(data)?;
                        *self.state =
                            SelectionConvergenceElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (SelectionConvergenceElementTypeDeserializerState :: ConnectionPointOut (Some (deserializer))) ;
                                *self.state =
                                    SelectionConvergenceElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = SelectionConvergenceElementTypeDeserializerState :: ConnectionPointOut (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<SelectionConvergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        SelectionConvergenceElementTypeDeserializerState::AddData(None),
                    );
                    *self.state =
                        SelectionConvergenceElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state =
                            SelectionConvergenceElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    SelectionConvergenceElementTypeDeserializerState::AddData(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    SelectionConvergenceElementTypeDeserializerState::Documentation(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    SelectionConvergenceElementTypeDeserializerState::AddData(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<SelectionConvergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        SelectionConvergenceElementTypeDeserializerState::Documentation(None),
                    );
                    *self.state = SelectionConvergenceElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = SelectionConvergenceElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    SelectionConvergenceElementTypeDeserializerState::Documentation(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    SelectionConvergenceElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    SelectionConvergenceElementTypeDeserializerState::Documentation(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::SelectionConvergenceElementType>
            for Box<SelectionConvergenceElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::SelectionConvergenceElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    SelectionConvergenceElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::SelectionConvergenceElementType>
            where
                R: DeserializeReader,
            {
                use SelectionConvergenceElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointOut(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                SelectionConvergenceElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointOut(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointOut",
                                false,
                            )?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::SelectionConvergenceElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    SelectionConvergenceElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::SelectionConvergenceElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_in: self.connection_point_in,
                    connection_point_out: self.connection_point_out,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct SimultaneousDivergenceElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            name: Option<::std::string::String>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_in: Option<super::ConnectionPointInType>,
            connection_point_out: Vec<super::LeftPowerRailConnectionPointOutElementType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<SimultaneousDivergenceElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum SimultaneousDivergenceElementTypeDeserializerState {
            Init__ , Position (Option << super :: PositionType as WithDeserializer > :: Deserializer >) , ConnectionPointIn (Option << super :: ConnectionPointInType as WithDeserializer > :: Deserializer >) , ConnectionPointOut (Option << super :: LeftPowerRailConnectionPointOutElementType as WithDeserializer > :: Deserializer >) , AddData (Option << super :: AddDataType as WithDeserializer > :: Deserializer >) , Documentation (Option << super :: FormattedTextType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl SimultaneousDivergenceElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut name: Option<::std::string::String> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    name: name,
                    global_id: global_id,
                    position: None,
                    connection_point_in: None,
                    connection_point_out: Vec::new(),
                    add_data: None,
                    documentation: None,
                    state: Box::new(SimultaneousDivergenceElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: SimultaneousDivergenceElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use SimultaneousDivergenceElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointOut(Some(deserializer)) => {
                        self.store_connection_point_out(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                if self.connection_point_in.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointIn",
                    )))?;
                }
                self.connection_point_in = Some(value);
                Ok(())
            }
            fn store_connection_point_out(
                &mut self,
                value: super::LeftPowerRailConnectionPointOutElementType,
            ) -> Result<(), Error> {
                self.connection_point_out.push(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<SimultaneousDivergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback.get_or_insert(
                            SimultaneousDivergenceElementTypeDeserializerState::Position(None),
                        );
                        *self.state =
                            SimultaneousDivergenceElementTypeDeserializerState::ConnectionPointIn(
                                None,
                            );
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state =
                            SimultaneousDivergenceElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state =
                            SimultaneousDivergenceElementTypeDeserializerState::ConnectionPointIn(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    SimultaneousDivergenceElementTypeDeserializerState::Position(
                                        Some(deserializer),
                                    ),
                                );
                                * self . state = SimultaneousDivergenceElementTypeDeserializerState :: ConnectionPointIn (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    SimultaneousDivergenceElementTypeDeserializerState::Position(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<SimultaneousDivergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        SimultaneousDivergenceElementTypeDeserializerState::ConnectionPointIn(None),
                    );
                    *self.state =
                        SimultaneousDivergenceElementTypeDeserializerState::ConnectionPointOut(
                            None,
                        );
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        *self.state =
                            SimultaneousDivergenceElementTypeDeserializerState::ConnectionPointOut(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (SimultaneousDivergenceElementTypeDeserializerState :: ConnectionPointIn (Some (deserializer))) ;
                                * self . state = SimultaneousDivergenceElementTypeDeserializerState :: ConnectionPointOut (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = SimultaneousDivergenceElementTypeDeserializerState :: ConnectionPointIn (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_out<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::LeftPowerRailConnectionPointOutElementType>,
                fallback: &mut Option<SimultaneousDivergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        SimultaneousDivergenceElementTypeDeserializerState::ConnectionPointOut(
                            None,
                        ),
                    );
                    *self.state = SimultaneousDivergenceElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_out(data)?;
                        *self.state =
                            SimultaneousDivergenceElementTypeDeserializerState::ConnectionPointOut(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (SimultaneousDivergenceElementTypeDeserializerState :: ConnectionPointOut (Some (deserializer))) ;
                                * self . state = SimultaneousDivergenceElementTypeDeserializerState :: ConnectionPointOut (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = SimultaneousDivergenceElementTypeDeserializerState :: ConnectionPointOut (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<SimultaneousDivergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        SimultaneousDivergenceElementTypeDeserializerState::AddData(None),
                    );
                    *self.state =
                        SimultaneousDivergenceElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state =
                            SimultaneousDivergenceElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    SimultaneousDivergenceElementTypeDeserializerState::AddData(
                                        Some(deserializer),
                                    ),
                                );
                                * self . state = SimultaneousDivergenceElementTypeDeserializerState :: Documentation (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    SimultaneousDivergenceElementTypeDeserializerState::AddData(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<SimultaneousDivergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        SimultaneousDivergenceElementTypeDeserializerState::Documentation(None),
                    );
                    *self.state = SimultaneousDivergenceElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = SimultaneousDivergenceElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (SimultaneousDivergenceElementTypeDeserializerState :: Documentation (Some (deserializer))) ;
                                *self.state =
                                    SimultaneousDivergenceElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = SimultaneousDivergenceElementTypeDeserializerState :: Documentation (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::SimultaneousDivergenceElementType>
            for Box<SimultaneousDivergenceElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::SimultaneousDivergenceElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    SimultaneousDivergenceElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::SimultaneousDivergenceElementType>
            where
                R: DeserializeReader,
            {
                use SimultaneousDivergenceElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointOut(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                SimultaneousDivergenceElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointOut(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointOut",
                                false,
                            )?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::SimultaneousDivergenceElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    SimultaneousDivergenceElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::SimultaneousDivergenceElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    name: self.name,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_in: self.connection_point_in,
                    connection_point_out: self.connection_point_out,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct SimultaneousConvergenceElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            height: Option<::core::primitive::f64>,
            width: Option<::core::primitive::f64>,
            global_id: Option<::std::string::String>,
            position: Option<super::PositionType>,
            connection_point_in: Vec<super::ConnectionPointInType>,
            connection_point_out: Option<super::ConnectionPointOutType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<SimultaneousConvergenceElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum SimultaneousConvergenceElementTypeDeserializerState {
            Init__,
            Position(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            ConnectionPointIn(
                Option<<super::ConnectionPointInType as WithDeserializer>::Deserializer>,
            ),
            ConnectionPointOut(
                Option<<super::ConnectionPointOutType as WithDeserializer>::Deserializer>,
            ),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl SimultaneousConvergenceElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    height: height,
                    width: width,
                    global_id: global_id,
                    position: None,
                    connection_point_in: Vec::new(),
                    connection_point_out: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(SimultaneousConvergenceElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: SimultaneousConvergenceElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use SimultaneousConvergenceElementTypeDeserializerState as S;
                match state {
                    S::Position(Some(deserializer)) => {
                        self.store_position(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointOut(Some(deserializer)) => {
                        self.store_connection_point_out(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"position",
                    )))?;
                }
                self.position = Some(value);
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                self.connection_point_in.push(value);
                Ok(())
            }
            fn store_connection_point_out(
                &mut self,
                value: super::ConnectionPointOutType,
            ) -> Result<(), Error> {
                if self.connection_point_out.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointOut",
                    )))?;
                }
                self.connection_point_out = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<SimultaneousConvergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.position.is_some() {
                        fallback.get_or_insert(
                            SimultaneousConvergenceElementTypeDeserializerState::Position(None),
                        );
                        *self.state =
                            SimultaneousConvergenceElementTypeDeserializerState::ConnectionPointIn(
                                None,
                            );
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state =
                            SimultaneousConvergenceElementTypeDeserializerState::Position(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_position(data)?;
                        *self.state =
                            SimultaneousConvergenceElementTypeDeserializerState::ConnectionPointIn(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    SimultaneousConvergenceElementTypeDeserializerState::Position(
                                        Some(deserializer),
                                    ),
                                );
                                * self . state = SimultaneousConvergenceElementTypeDeserializerState :: ConnectionPointIn (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    SimultaneousConvergenceElementTypeDeserializerState::Position(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<SimultaneousConvergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        SimultaneousConvergenceElementTypeDeserializerState::ConnectionPointIn(
                            None,
                        ),
                    );
                    *self.state =
                        SimultaneousConvergenceElementTypeDeserializerState::ConnectionPointOut(
                            None,
                        );
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        *self.state =
                            SimultaneousConvergenceElementTypeDeserializerState::ConnectionPointIn(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (SimultaneousConvergenceElementTypeDeserializerState :: ConnectionPointIn (Some (deserializer))) ;
                                * self . state = SimultaneousConvergenceElementTypeDeserializerState :: ConnectionPointIn (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = SimultaneousConvergenceElementTypeDeserializerState :: ConnectionPointIn (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_out<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointOutType>,
                fallback: &mut Option<SimultaneousConvergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        SimultaneousConvergenceElementTypeDeserializerState::ConnectionPointOut(
                            None,
                        ),
                    );
                    *self.state =
                        SimultaneousConvergenceElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_out(data)?;
                        *self.state =
                            SimultaneousConvergenceElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (SimultaneousConvergenceElementTypeDeserializerState :: ConnectionPointOut (Some (deserializer))) ;
                                *self.state =
                                    SimultaneousConvergenceElementTypeDeserializerState::AddData(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = SimultaneousConvergenceElementTypeDeserializerState :: ConnectionPointOut (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<SimultaneousConvergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        SimultaneousConvergenceElementTypeDeserializerState::AddData(None),
                    );
                    *self.state =
                        SimultaneousConvergenceElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state =
                            SimultaneousConvergenceElementTypeDeserializerState::Documentation(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    SimultaneousConvergenceElementTypeDeserializerState::AddData(
                                        Some(deserializer),
                                    ),
                                );
                                * self . state = SimultaneousConvergenceElementTypeDeserializerState :: Documentation (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    SimultaneousConvergenceElementTypeDeserializerState::AddData(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<SimultaneousConvergenceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        SimultaneousConvergenceElementTypeDeserializerState::Documentation(None),
                    );
                    *self.state = SimultaneousConvergenceElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = SimultaneousConvergenceElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (SimultaneousConvergenceElementTypeDeserializerState :: Documentation (Some (deserializer))) ;
                                *self.state =
                                    SimultaneousConvergenceElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = SimultaneousConvergenceElementTypeDeserializerState :: Documentation (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::SimultaneousConvergenceElementType>
            for Box<SimultaneousConvergenceElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::SimultaneousConvergenceElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    SimultaneousConvergenceElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::SimultaneousConvergenceElementType>
            where
                R: DeserializeReader,
            {
                use SimultaneousConvergenceElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Position(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointOut(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                SimultaneousConvergenceElementTypeDeserializerState::Position(None);
                            event
                        }
                        (S::Position(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"position",
                                false,
                            )?;
                            match self.handle_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointOut(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointOut",
                                false,
                            )?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::SimultaneousConvergenceElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    SimultaneousConvergenceElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::SimultaneousConvergenceElementType {
                    local_id: self.local_id,
                    height: self.height,
                    width: self.width,
                    global_id: self.global_id,
                    position: self
                        .position
                        .ok_or_else(|| ErrorKind::MissingElement("position".into()))?,
                    connection_point_in: self.connection_point_in,
                    connection_point_out: self.connection_point_out,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct EnumValuesElementTypeDeserializer {
            content: Vec<super::EnumValuesElementTypeContent>,
            state: Box<EnumValuesElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum EnumValuesElementTypeDeserializerState {
            Init__,
            Next__,
            Content__(<super::EnumValuesElementTypeContent as WithDeserializer>::Deserializer),
            Unknown__,
        }
        impl EnumValuesElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    content: Vec::new(),
                    state: Box::new(EnumValuesElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: EnumValuesElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                if let EnumValuesElementTypeDeserializerState::Content__(deserializer) = state {
                    self.store_content(deserializer.finish(reader)?)?;
                }
                Ok(())
            }
            fn store_content(
                &mut self,
                value: super::EnumValuesElementTypeContent,
            ) -> Result<(), Error> {
                self.content.push(value);
                Ok(())
            }
            fn handle_content<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::EnumValuesElementTypeContent>,
                fallback: &mut Option<EnumValuesElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = fallback
                        .take()
                        .unwrap_or(EnumValuesElementTypeDeserializerState::Next__);
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_content(data)?;
                        *self.state = EnumValuesElementTypeDeserializerState::Next__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    EnumValuesElementTypeDeserializerState::Content__(deserializer);
                            }
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    EnumValuesElementTypeDeserializerState::Content__(deserializer),
                                );
                                *self.state = EnumValuesElementTypeDeserializerState::Next__;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::EnumValuesElementType>
            for Box<EnumValuesElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::EnumValuesElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    EnumValuesElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::EnumValuesElementType>
            where
                R: DeserializeReader,
            {
                use EnumValuesElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Content__(deserializer), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (_, Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (state @ (S::Init__ | S::Next__), event) => {
                            fallback.get_or_insert(state);
                            let output = < super :: EnumValuesElementTypeContent as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = DeserializerArtifact::Deserializer(self);
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::EnumValuesElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    EnumValuesElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::EnumValuesElementType {
                    content: self.content,
                })
            }
        }
        #[derive(Debug)]
        pub struct EnumValuesElementTypeContentDeserializer {
            value: Option<super::EnumValuesValueElementType>,
            state: Box<EnumValuesElementTypeContentDeserializerState>,
        }
        #[derive(Debug)]
        enum EnumValuesElementTypeContentDeserializerState {
            Init__,
            Value(Option<<super::EnumValuesValueElementType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl EnumValuesElementTypeContentDeserializer {
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: EnumValuesElementTypeContentDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use EnumValuesElementTypeContentDeserializerState as S;
                match state {
                    S::Value(Some(deserializer)) => {
                        self.store_value(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_value(
                &mut self,
                value: super::EnumValuesValueElementType,
            ) -> Result<(), Error> {
                if self.value.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"value",
                    )))?;
                }
                self.value = Some(value);
                Ok(())
            }
            fn handle_value<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::EnumValuesValueElementType>,
                fallback: &mut Option<EnumValuesElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.value.is_some() {
                        fallback.get_or_insert(
                            EnumValuesElementTypeContentDeserializerState::Value(None),
                        );
                        *self.state = EnumValuesElementTypeContentDeserializerState::Done__;
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state = EnumValuesElementTypeContentDeserializerState::Value(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_value(data)?;
                        *self.state = EnumValuesElementTypeContentDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    EnumValuesElementTypeContentDeserializerState::Value(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state = EnumValuesElementTypeContentDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = EnumValuesElementTypeContentDeserializerState::Value(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::EnumValuesElementTypeContent>
            for Box<EnumValuesElementTypeContentDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::EnumValuesElementTypeContent>
            where
                R: DeserializeReader,
            {
                let deserializer = Box::new(EnumValuesElementTypeContentDeserializer {
                    value: None,
                    state: Box::new(EnumValuesElementTypeContentDeserializerState::Init__),
                });
                let mut output = deserializer.next(reader, event)?;
                output.artifact = match output.artifact {
                    DeserializerArtifact::Deserializer(x)
                        if matches!(
                            &*x.state,
                            EnumValuesElementTypeContentDeserializerState::Init__
                        ) =>
                    {
                        DeserializerArtifact::None
                    }
                    artifact => artifact,
                };
                Ok(output)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::EnumValuesElementTypeContent>
            where
                R: DeserializeReader,
            {
                use EnumValuesElementTypeContentDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Value(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_value(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, event @ Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::Continue(event),
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                EnumValuesElementTypeContentDeserializerState::Value(None);
                            event
                        }
                        (S::Value(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"value",
                                false,
                            )?;
                            match self.handle_value(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::EnumValuesElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    EnumValuesElementTypeContentDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::EnumValuesElementTypeContent {
                    value: self
                        .value
                        .ok_or_else(|| ErrorKind::MissingElement("value".into()))?,
                })
            }
        }
        #[derive(Debug)]
        pub struct ProjectContentHeaderCoordinateInfoElementTypeDeserializer {
            page_size: Option<super::PositionType>,
            fbd: Option<super::ProjectContentHeaderCoordinateInfoFbdElementType>,
            ld: Option<super::ProjectContentHeaderCoordinateInfoFbdElementType>,
            sfc: Option<super::ProjectContentHeaderCoordinateInfoFbdElementType>,
            state: Box<ProjectContentHeaderCoordinateInfoElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectContentHeaderCoordinateInfoElementTypeDeserializerState {
            Init__ , PageSize (Option << super :: PositionType as WithDeserializer > :: Deserializer >) , Fbd (Option << super :: ProjectContentHeaderCoordinateInfoFbdElementType as WithDeserializer > :: Deserializer >) , Ld (Option << super :: ProjectContentHeaderCoordinateInfoFbdElementType as WithDeserializer > :: Deserializer >) , Sfc (Option << super :: ProjectContentHeaderCoordinateInfoFbdElementType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl ProjectContentHeaderCoordinateInfoElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    page_size: None,
                    fbd: None,
                    ld: None,
                    sfc: None,
                    state: Box::new(
                        ProjectContentHeaderCoordinateInfoElementTypeDeserializerState::Init__,
                    ),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectContentHeaderCoordinateInfoElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectContentHeaderCoordinateInfoElementTypeDeserializerState as S;
                match state {
                    S::PageSize(Some(deserializer)) => {
                        self.store_page_size(deserializer.finish(reader)?)?
                    }
                    S::Fbd(Some(deserializer)) => self.store_fbd(deserializer.finish(reader)?)?,
                    S::Ld(Some(deserializer)) => self.store_ld(deserializer.finish(reader)?)?,
                    S::Sfc(Some(deserializer)) => self.store_sfc(deserializer.finish(reader)?)?,
                    _ => (),
                }
                Ok(())
            }
            fn store_page_size(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.page_size.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"pageSize",
                    )))?;
                }
                self.page_size = Some(value);
                Ok(())
            }
            fn store_fbd(
                &mut self,
                value: super::ProjectContentHeaderCoordinateInfoFbdElementType,
            ) -> Result<(), Error> {
                if self.fbd.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"fbd")))?;
                }
                self.fbd = Some(value);
                Ok(())
            }
            fn store_ld(
                &mut self,
                value: super::ProjectContentHeaderCoordinateInfoFbdElementType,
            ) -> Result<(), Error> {
                if self.ld.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"ld")))?;
                }
                self.ld = Some(value);
                Ok(())
            }
            fn store_sfc(
                &mut self,
                value: super::ProjectContentHeaderCoordinateInfoFbdElementType,
            ) -> Result<(), Error> {
                if self.sfc.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"sfc")))?;
                }
                self.sfc = Some(value);
                Ok(())
            }
            fn handle_page_size<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<
                    ProjectContentHeaderCoordinateInfoElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectContentHeaderCoordinateInfoElementTypeDeserializerState::PageSize(
                            None,
                        ),
                    );
                    *self.state =
                        ProjectContentHeaderCoordinateInfoElementTypeDeserializerState::Fbd(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_page_size(data)?;
                        *self.state =
                            ProjectContentHeaderCoordinateInfoElementTypeDeserializerState::Fbd(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectContentHeaderCoordinateInfoElementTypeDeserializerState :: PageSize (Some (deserializer))) ;
                                * self . state = ProjectContentHeaderCoordinateInfoElementTypeDeserializerState :: Fbd (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectContentHeaderCoordinateInfoElementTypeDeserializerState :: PageSize (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_fbd<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<
                    'de,
                    super::ProjectContentHeaderCoordinateInfoFbdElementType,
                >,
                fallback: &mut Option<
                    ProjectContentHeaderCoordinateInfoElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.fbd.is_some() {
                        fallback.get_or_insert(
                            ProjectContentHeaderCoordinateInfoElementTypeDeserializerState::Fbd(
                                None,
                            ),
                        );
                        *self.state =
                            ProjectContentHeaderCoordinateInfoElementTypeDeserializerState::Ld(
                                None,
                            );
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state =
                            ProjectContentHeaderCoordinateInfoElementTypeDeserializerState::Fbd(
                                None,
                            );
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_fbd(data)?;
                        *self.state =
                            ProjectContentHeaderCoordinateInfoElementTypeDeserializerState::Ld(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectContentHeaderCoordinateInfoElementTypeDeserializerState :: Fbd (Some (deserializer))) ;
                                * self . state = ProjectContentHeaderCoordinateInfoElementTypeDeserializerState :: Ld (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectContentHeaderCoordinateInfoElementTypeDeserializerState :: Fbd (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_ld<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<
                    'de,
                    super::ProjectContentHeaderCoordinateInfoFbdElementType,
                >,
                fallback: &mut Option<
                    ProjectContentHeaderCoordinateInfoElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.ld.is_some() {
                        fallback.get_or_insert(
                            ProjectContentHeaderCoordinateInfoElementTypeDeserializerState::Ld(
                                None,
                            ),
                        );
                        *self.state =
                            ProjectContentHeaderCoordinateInfoElementTypeDeserializerState::Sfc(
                                None,
                            );
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state =
                            ProjectContentHeaderCoordinateInfoElementTypeDeserializerState::Ld(
                                None,
                            );
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_ld(data)?;
                        *self.state =
                            ProjectContentHeaderCoordinateInfoElementTypeDeserializerState::Sfc(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectContentHeaderCoordinateInfoElementTypeDeserializerState :: Ld (Some (deserializer))) ;
                                * self . state = ProjectContentHeaderCoordinateInfoElementTypeDeserializerState :: Sfc (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectContentHeaderCoordinateInfoElementTypeDeserializerState :: Ld (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_sfc<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<
                    'de,
                    super::ProjectContentHeaderCoordinateInfoFbdElementType,
                >,
                fallback: &mut Option<
                    ProjectContentHeaderCoordinateInfoElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.sfc.is_some() {
                        fallback.get_or_insert(
                            ProjectContentHeaderCoordinateInfoElementTypeDeserializerState::Sfc(
                                None,
                            ),
                        );
                        *self.state =
                            ProjectContentHeaderCoordinateInfoElementTypeDeserializerState::Done__;
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state =
                            ProjectContentHeaderCoordinateInfoElementTypeDeserializerState::Sfc(
                                None,
                            );
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_sfc(data)?;
                        *self.state =
                            ProjectContentHeaderCoordinateInfoElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectContentHeaderCoordinateInfoElementTypeDeserializerState :: Sfc (Some (deserializer))) ;
                                * self . state = ProjectContentHeaderCoordinateInfoElementTypeDeserializerState :: Done__ ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectContentHeaderCoordinateInfoElementTypeDeserializerState :: Sfc (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectContentHeaderCoordinateInfoElementType>
            for Box<ProjectContentHeaderCoordinateInfoElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectContentHeaderCoordinateInfoElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ProjectContentHeaderCoordinateInfoElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectContentHeaderCoordinateInfoElementType>
            where
                R: DeserializeReader,
            {
                use ProjectContentHeaderCoordinateInfoElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::PageSize(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_page_size(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Fbd(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_fbd(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Ld(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_ld(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Sfc(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_sfc(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            * self . state = ProjectContentHeaderCoordinateInfoElementTypeDeserializerState :: PageSize (None) ;
                            event
                        }
                        (S::PageSize(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"pageSize",
                                false,
                            )?;
                            match self.handle_page_size(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Fbd(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"fbd",
                                false,
                            )?;
                            match self.handle_fbd(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Ld(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"ld",
                                false,
                            )?;
                            match self.handle_ld(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Sfc(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"sfc",
                                false,
                            )?;
                            match self.handle_sfc(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ProjectContentHeaderCoordinateInfoElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ProjectContentHeaderCoordinateInfoElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ProjectContentHeaderCoordinateInfoElementType {
                    page_size: self.page_size,
                    fbd: self
                        .fbd
                        .ok_or_else(|| ErrorKind::MissingElement("fbd".into()))?,
                    ld: self
                        .ld
                        .ok_or_else(|| ErrorKind::MissingElement("ld".into()))?,
                    sfc: self
                        .sfc
                        .ok_or_else(|| ErrorKind::MissingElement("sfc".into()))?,
                })
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesDataTypesElementTypeDeserializer {
            data_type: Vec<super::ProjectTypesDataTypesDataTypeElementType>,
            state: Box<ProjectTypesDataTypesElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectTypesDataTypesElementTypeDeserializerState {
            Init__ , DataType (Option << super :: ProjectTypesDataTypesDataTypeElementType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl ProjectTypesDataTypesElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    data_type: Vec::new(),
                    state: Box::new(ProjectTypesDataTypesElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectTypesDataTypesElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectTypesDataTypesElementTypeDeserializerState as S;
                match state {
                    S::DataType(Some(deserializer)) => {
                        self.store_data_type(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_data_type(
                &mut self,
                value: super::ProjectTypesDataTypesDataTypeElementType,
            ) -> Result<(), Error> {
                self.data_type.push(value);
                Ok(())
            }
            fn handle_data_type<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ProjectTypesDataTypesDataTypeElementType>,
                fallback: &mut Option<ProjectTypesDataTypesElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectTypesDataTypesElementTypeDeserializerState::DataType(None),
                    );
                    *self.state = ProjectTypesDataTypesElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_data_type(data)?;
                        *self.state =
                            ProjectTypesDataTypesElementTypeDeserializerState::DataType(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectTypesDataTypesElementTypeDeserializerState::DataType(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    ProjectTypesDataTypesElementTypeDeserializerState::DataType(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ProjectTypesDataTypesElementTypeDeserializerState::DataType(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectTypesDataTypesElementType>
            for Box<ProjectTypesDataTypesElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesDataTypesElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ProjectTypesDataTypesElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesDataTypesElementType>
            where
                R: DeserializeReader,
            {
                use ProjectTypesDataTypesElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::DataType(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_data_type(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                ProjectTypesDataTypesElementTypeDeserializerState::DataType(None);
                            event
                        }
                        (S::DataType(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"dataType",
                                true,
                            )?;
                            match self.handle_data_type(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ProjectTypesDataTypesElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ProjectTypesDataTypesElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ProjectTypesDataTypesElementType {
                    data_type: self.data_type,
                })
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesPousElementTypeDeserializer {
            pou: Vec<super::ProjectTypesPousPouElementType>,
            state: Box<ProjectTypesPousElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectTypesPousElementTypeDeserializerState {
            Init__,
            Pou(Option<<super::ProjectTypesPousPouElementType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl ProjectTypesPousElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    pou: Vec::new(),
                    state: Box::new(ProjectTypesPousElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectTypesPousElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectTypesPousElementTypeDeserializerState as S;
                match state {
                    S::Pou(Some(deserializer)) => self.store_pou(deserializer.finish(reader)?)?,
                    _ => (),
                }
                Ok(())
            }
            fn store_pou(
                &mut self,
                value: super::ProjectTypesPousPouElementType,
            ) -> Result<(), Error> {
                self.pou.push(value);
                Ok(())
            }
            fn handle_pou<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ProjectTypesPousPouElementType>,
                fallback: &mut Option<ProjectTypesPousElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(ProjectTypesPousElementTypeDeserializerState::Pou(None));
                    *self.state = ProjectTypesPousElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_pou(data)?;
                        *self.state = ProjectTypesPousElementTypeDeserializerState::Pou(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectTypesPousElementTypeDeserializerState::Pou(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    ProjectTypesPousElementTypeDeserializerState::Pou(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ProjectTypesPousElementTypeDeserializerState::Pou(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectTypesPousElementType>
            for Box<ProjectTypesPousElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesPousElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ProjectTypesPousElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesPousElementType>
            where
                R: DeserializeReader,
            {
                use ProjectTypesPousElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Pou(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_pou(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = ProjectTypesPousElementTypeDeserializerState::Pou(None);
                            event
                        }
                        (S::Pou(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"pou",
                                true,
                            )?;
                            match self.handle_pou(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::ProjectTypesPousElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ProjectTypesPousElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ProjectTypesPousElementType { pou: self.pou })
            }
        }
        #[derive(Debug)]
        pub struct ProjectInstancesConfigurationsElementTypeDeserializer {
            configuration: Vec<super::ProjectInstancesConfigurationsConfigurationElementType>,
            state: Box<ProjectInstancesConfigurationsElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectInstancesConfigurationsElementTypeDeserializerState {
            Init__ , Configuration (Option << super :: ProjectInstancesConfigurationsConfigurationElementType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl ProjectInstancesConfigurationsElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    configuration: Vec::new(),
                    state: Box::new(
                        ProjectInstancesConfigurationsElementTypeDeserializerState::Init__,
                    ),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectInstancesConfigurationsElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectInstancesConfigurationsElementTypeDeserializerState as S;
                match state {
                    S::Configuration(Some(deserializer)) => {
                        self.store_configuration(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_configuration(
                &mut self,
                value: super::ProjectInstancesConfigurationsConfigurationElementType,
            ) -> Result<(), Error> {
                self.configuration.push(value);
                Ok(())
            }
            fn handle_configuration<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<
                    'de,
                    super::ProjectInstancesConfigurationsConfigurationElementType,
                >,
                fallback: &mut Option<ProjectInstancesConfigurationsElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectInstancesConfigurationsElementTypeDeserializerState::Configuration(
                            None,
                        ),
                    );
                    *self.state =
                        ProjectInstancesConfigurationsElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_configuration(data)?;
                        * self . state = ProjectInstancesConfigurationsElementTypeDeserializerState :: Configuration (None) ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectInstancesConfigurationsElementTypeDeserializerState :: Configuration (Some (deserializer))) ;
                                * self . state = ProjectInstancesConfigurationsElementTypeDeserializerState :: Configuration (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectInstancesConfigurationsElementTypeDeserializerState :: Configuration (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectInstancesConfigurationsElementType>
            for Box<ProjectInstancesConfigurationsElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectInstancesConfigurationsElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ProjectInstancesConfigurationsElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectInstancesConfigurationsElementType>
            where
                R: DeserializeReader,
            {
                use ProjectInstancesConfigurationsElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Configuration(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_configuration(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            * self . state = ProjectInstancesConfigurationsElementTypeDeserializerState :: Configuration (None) ;
                            event
                        }
                        (S::Configuration(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"configuration",
                                true,
                            )?;
                            match self.handle_configuration(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ProjectInstancesConfigurationsElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ProjectInstancesConfigurationsElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ProjectInstancesConfigurationsElementType {
                    configuration: self.configuration,
                })
            }
        }
        #[derive(Debug)]
        pub struct ValueArrayValueValueElementTypeDeserializer {
            repetition_value: ::std::string::String,
            content: Option<super::ValueArrayValueValueElementTypeContent>,
            state: Box<ValueArrayValueValueElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ValueArrayValueValueElementTypeDeserializerState {
            Init__,
            Next__,
            Content__(
                <super::ValueArrayValueValueElementTypeContent as WithDeserializer>::Deserializer,
            ),
            Unknown__,
        }
        impl ValueArrayValueValueElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut repetition_value: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"repetitionValue")
                    ) {
                        reader.read_attrib(
                            &mut repetition_value,
                            b"repetitionValue",
                            &attrib.value,
                        )?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    repetition_value: repetition_value.unwrap_or_else(
                        super::ValueArrayValueValueElementType::default_repetition_value,
                    ),
                    content: None,
                    state: Box::new(ValueArrayValueValueElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ValueArrayValueValueElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                if let ValueArrayValueValueElementTypeDeserializerState::Content__(deserializer) =
                    state
                {
                    self.store_content(deserializer.finish(reader)?)?;
                }
                Ok(())
            }
            fn store_content(
                &mut self,
                value: super::ValueArrayValueValueElementTypeContent,
            ) -> Result<(), Error> {
                if self.content.is_some() {
                    Err(ErrorKind::DuplicateContent)?;
                }
                self.content = Some(value);
                Ok(())
            }
            fn handle_content<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ValueArrayValueValueElementTypeContent>,
                fallback: &mut Option<ValueArrayValueValueElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = fallback
                        .take()
                        .unwrap_or(ValueArrayValueValueElementTypeDeserializerState::Next__);
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_content(data)?;
                        *self.state = ValueArrayValueValueElementTypeDeserializerState::Next__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = ValueArrayValueValueElementTypeDeserializerState::Content__(
                            deserializer,
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ValueArrayValueValueElementType>
            for Box<ValueArrayValueValueElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueArrayValueValueElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ValueArrayValueValueElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueArrayValueValueElementType>
            where
                R: DeserializeReader,
            {
                use ValueArrayValueValueElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Content__(deserializer), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (_, Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (state @ (S::Init__ | S::Next__), event) => {
                            fallback.get_or_insert(state);
                            let output = < super :: ValueArrayValueValueElementTypeContent as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = DeserializerArtifact::Deserializer(self);
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ValueArrayValueValueElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ValueArrayValueValueElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ValueArrayValueValueElementType {
                    repetition_value: self.repetition_value,
                    content: self.content.ok_or_else(|| ErrorKind::MissingContent)?,
                })
            }
        }
        #[derive(Debug)]
        pub struct ValueArrayValueValueElementTypeContentDeserializer {
            state: Box<ValueArrayValueValueElementTypeContentDeserializerState>,
        }
        #[derive(Debug)]
        pub enum ValueArrayValueValueElementTypeContentDeserializerState {
            Init__,
            SimpleValue(
                Option<super::ValueSimpleValueElementType>,
                Option<<super::ValueSimpleValueElementType as WithDeserializer>::Deserializer>,
            ),
            ArrayValue(
                Option<super::ValueArrayValueElementType>,
                Option<<super::ValueArrayValueElementType as WithDeserializer>::Deserializer>,
            ),
            StructValue(
                Option<super::ValueStructValueElementType>,
                Option<<super::ValueStructValueElementType as WithDeserializer>::Deserializer>,
            ),
            Done__(super::ValueArrayValueValueElementTypeContent),
            Unknown__,
        }
        impl ValueArrayValueValueElementTypeContentDeserializer {
            fn find_suitable<'de, R>(
                &mut self,
                reader: &R,
                event: Event<'de>,
                fallback: &mut Option<ValueArrayValueValueElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                if let Event::Start(x) | Event::Empty(x) = &event {
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"simpleValue")
                    ) {
                        let output = < super :: ValueSimpleValueElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_simple_value(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"arrayValue")
                    ) {
                        let output = < super :: ValueArrayValueElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_array_value(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"structValue")
                    ) {
                        let output = < super :: ValueStructValueElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_struct_value(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                }
                *self.state = fallback
                    .take()
                    .unwrap_or(ValueArrayValueValueElementTypeContentDeserializerState::Init__);
                Ok(ElementHandlerOutput::return_to_parent(event, false))
            }
            fn finish_state<R>(
                reader: &R,
                state: ValueArrayValueValueElementTypeContentDeserializerState,
            ) -> Result<super::ValueArrayValueValueElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                use ValueArrayValueValueElementTypeContentDeserializerState as S;
                match state {
                    S::Init__ => Err(ErrorKind::MissingContent.into()),
                    S::SimpleValue(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ValueArrayValueValueElementTypeContentDeserializer::store_simple_value(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::ValueArrayValueValueElementTypeContent::SimpleValue(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("simpleValue".into()))?,
                        ))
                    }
                    S::ArrayValue(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ValueArrayValueValueElementTypeContentDeserializer::store_array_value(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::ValueArrayValueValueElementTypeContent::ArrayValue(
                            values.ok_or_else(|| ErrorKind::MissingElement("arrayValue".into()))?,
                        ))
                    }
                    S::StructValue(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ValueArrayValueValueElementTypeContentDeserializer::store_struct_value(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::ValueArrayValueValueElementTypeContent::StructValue(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("structValue".into()))?,
                        ))
                    }
                    S::Done__(data) => Ok(data),
                    S::Unknown__ => unreachable!(),
                }
            }
            fn store_simple_value(
                values: &mut Option<super::ValueSimpleValueElementType>,
                value: super::ValueSimpleValueElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"simpleValue",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_array_value(
                values: &mut Option<super::ValueArrayValueElementType>,
                value: super::ValueArrayValueElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"arrayValue",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_struct_value(
                values: &mut Option<super::ValueStructValueElementType>,
                value: super::ValueStructValueElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"structValue",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn handle_simple_value<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ValueSimpleValueElementType>,
                output: DeserializerOutput<'de, super::ValueSimpleValueElementType>,
                fallback: &mut Option<ValueArrayValueValueElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state =
                                ValueArrayValueValueElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            ValueArrayValueValueElementTypeContentDeserializerState::SimpleValue(
                                values, None,
                            )
                        }
                        Some(
                            ValueArrayValueValueElementTypeContentDeserializerState::SimpleValue(
                                _,
                                Some(deserializer),
                            ),
                        ) => ValueArrayValueValueElementTypeContentDeserializerState::SimpleValue(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(ValueArrayValueValueElementTypeContentDeserializerState::SimpleValue(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        ValueArrayValueValueElementTypeContentDeserializer::store_simple_value(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ValueArrayValueValueElementTypeContentDeserializer::store_simple_value(
                            &mut values,
                            data,
                        )?;
                        let data = ValueArrayValueValueElementTypeContentDeserializer :: finish_state (reader , ValueArrayValueValueElementTypeContentDeserializerState :: SimpleValue (values , None)) ? ;
                        *self.state =
                            ValueArrayValueValueElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            ValueArrayValueValueElementTypeContentDeserializerState::SimpleValue(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_array_value<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ValueArrayValueElementType>,
                output: DeserializerOutput<'de, super::ValueArrayValueElementType>,
                fallback: &mut Option<ValueArrayValueValueElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state =
                                ValueArrayValueValueElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            ValueArrayValueValueElementTypeContentDeserializerState::ArrayValue(
                                values, None,
                            )
                        }
                        Some(
                            ValueArrayValueValueElementTypeContentDeserializerState::ArrayValue(
                                _,
                                Some(deserializer),
                            ),
                        ) => ValueArrayValueValueElementTypeContentDeserializerState::ArrayValue(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(ValueArrayValueValueElementTypeContentDeserializerState::ArrayValue(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        ValueArrayValueValueElementTypeContentDeserializer::store_array_value(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ValueArrayValueValueElementTypeContentDeserializer::store_array_value(
                            &mut values,
                            data,
                        )?;
                        let data =
                            ValueArrayValueValueElementTypeContentDeserializer::finish_state(
                                reader,
                                ValueArrayValueValueElementTypeContentDeserializerState::ArrayValue(
                                    values, None,
                                ),
                            )?;
                        *self.state =
                            ValueArrayValueValueElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            ValueArrayValueValueElementTypeContentDeserializerState::ArrayValue(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_struct_value<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ValueStructValueElementType>,
                output: DeserializerOutput<'de, super::ValueStructValueElementType>,
                fallback: &mut Option<ValueArrayValueValueElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state =
                                ValueArrayValueValueElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            ValueArrayValueValueElementTypeContentDeserializerState::StructValue(
                                values, None,
                            )
                        }
                        Some(
                            ValueArrayValueValueElementTypeContentDeserializerState::StructValue(
                                _,
                                Some(deserializer),
                            ),
                        ) => ValueArrayValueValueElementTypeContentDeserializerState::StructValue(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(ValueArrayValueValueElementTypeContentDeserializerState::StructValue(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        ValueArrayValueValueElementTypeContentDeserializer::store_struct_value(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ValueArrayValueValueElementTypeContentDeserializer::store_struct_value(
                            &mut values,
                            data,
                        )?;
                        let data = ValueArrayValueValueElementTypeContentDeserializer :: finish_state (reader , ValueArrayValueValueElementTypeContentDeserializerState :: StructValue (values , None)) ? ;
                        *self.state =
                            ValueArrayValueValueElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            ValueArrayValueValueElementTypeContentDeserializerState::StructValue(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ValueArrayValueValueElementTypeContent>
            for Box<ValueArrayValueValueElementTypeContentDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueArrayValueValueElementTypeContent>
            where
                R: DeserializeReader,
            {
                let deserializer = Box::new(ValueArrayValueValueElementTypeContentDeserializer {
                    state: Box::new(
                        ValueArrayValueValueElementTypeContentDeserializerState::Init__,
                    ),
                });
                let mut output = deserializer.next(reader, event)?;
                output.artifact = match output.artifact {
                    DeserializerArtifact::Deserializer(x)
                        if matches!(
                            &*x.state,
                            ValueArrayValueValueElementTypeContentDeserializerState::Init__
                        ) =>
                    {
                        DeserializerArtifact::None
                    }
                    artifact => artifact,
                };
                Ok(output)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueArrayValueValueElementTypeContent>
            where
                R: DeserializeReader,
            {
                use ValueArrayValueValueElementTypeContentDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::SimpleValue(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_simple_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::ArrayValue(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_array_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::StructValue(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_struct_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (state, event @ Event::End(_)) => {
                            return Ok (DeserializerOutput { artifact : DeserializerArtifact :: Data (ValueArrayValueValueElementTypeContentDeserializer :: finish_state (reader , state) ?) , event : DeserializerEvent :: Continue (event) , allow_any : false , }) ;
                        }
                        (S::Init__, event) => {
                            match self.find_suitable(reader, event, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::SimpleValue(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"simpleValue",
                                false,
                            )?;
                            match self.handle_simple_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::ArrayValue(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"arrayValue",
                                false,
                            )?;
                            match self.handle_array_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::StructValue(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"structValue",
                                false,
                            )?;
                            match self.handle_struct_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (s @ S::Done__(_), event) => {
                            *self.state = s;
                            break (DeserializerEvent::Continue(event), false);
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = if matches!(&*self.state, S::Done__(_)) {
                    DeserializerArtifact::Data(self.finish(reader)?)
                } else {
                    DeserializerArtifact::Deserializer(self)
                };
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                self,
                reader: &R,
            ) -> Result<super::ValueArrayValueValueElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                ValueArrayValueValueElementTypeContentDeserializer::finish_state(
                    reader,
                    *self.state,
                )
            }
        }
        #[derive(Debug)]
        pub struct ValueStructValueValueElementTypeDeserializer {
            member: ::std::string::String,
            content: Option<super::ValueStructValueValueElementTypeContent>,
            state: Box<ValueStructValueValueElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ValueStructValueValueElementTypeDeserializerState {
            Init__,
            Next__,
            Content__(
                <super::ValueStructValueValueElementTypeContent as WithDeserializer>::Deserializer,
            ),
            Unknown__,
        }
        impl ValueStructValueValueElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut member: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"member")
                    ) {
                        reader.read_attrib(&mut member, b"member", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    member: member.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("member".into()))
                    })?,
                    content: None,
                    state: Box::new(ValueStructValueValueElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ValueStructValueValueElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                if let ValueStructValueValueElementTypeDeserializerState::Content__(deserializer) =
                    state
                {
                    self.store_content(deserializer.finish(reader)?)?;
                }
                Ok(())
            }
            fn store_content(
                &mut self,
                value: super::ValueStructValueValueElementTypeContent,
            ) -> Result<(), Error> {
                if self.content.is_some() {
                    Err(ErrorKind::DuplicateContent)?;
                }
                self.content = Some(value);
                Ok(())
            }
            fn handle_content<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ValueStructValueValueElementTypeContent>,
                fallback: &mut Option<ValueStructValueValueElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = fallback
                        .take()
                        .unwrap_or(ValueStructValueValueElementTypeDeserializerState::Next__);
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_content(data)?;
                        *self.state = ValueStructValueValueElementTypeDeserializerState::Next__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = ValueStructValueValueElementTypeDeserializerState::Content__(
                            deserializer,
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ValueStructValueValueElementType>
            for Box<ValueStructValueValueElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueStructValueValueElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ValueStructValueValueElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueStructValueValueElementType>
            where
                R: DeserializeReader,
            {
                use ValueStructValueValueElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Content__(deserializer), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (_, Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (state @ (S::Init__ | S::Next__), event) => {
                            fallback.get_or_insert(state);
                            let output = < super :: ValueStructValueValueElementTypeContent as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = DeserializerArtifact::Deserializer(self);
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ValueStructValueValueElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ValueStructValueValueElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ValueStructValueValueElementType {
                    member: self.member,
                    content: self.content.ok_or_else(|| ErrorKind::MissingContent)?,
                })
            }
        }
        #[derive(Debug)]
        pub struct ValueStructValueValueElementTypeContentDeserializer {
            state: Box<ValueStructValueValueElementTypeContentDeserializerState>,
        }
        #[derive(Debug)]
        pub enum ValueStructValueValueElementTypeContentDeserializerState {
            Init__,
            SimpleValue(
                Option<super::ValueSimpleValueElementType>,
                Option<<super::ValueSimpleValueElementType as WithDeserializer>::Deserializer>,
            ),
            ArrayValue(
                Option<super::ValueArrayValueElementType>,
                Option<<super::ValueArrayValueElementType as WithDeserializer>::Deserializer>,
            ),
            StructValue(
                Option<super::ValueStructValueElementType>,
                Option<<super::ValueStructValueElementType as WithDeserializer>::Deserializer>,
            ),
            Done__(super::ValueStructValueValueElementTypeContent),
            Unknown__,
        }
        impl ValueStructValueValueElementTypeContentDeserializer {
            fn find_suitable<'de, R>(
                &mut self,
                reader: &R,
                event: Event<'de>,
                fallback: &mut Option<ValueStructValueValueElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                if let Event::Start(x) | Event::Empty(x) = &event {
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"simpleValue")
                    ) {
                        let output = < super :: ValueSimpleValueElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_simple_value(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"arrayValue")
                    ) {
                        let output = < super :: ValueArrayValueElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_array_value(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"structValue")
                    ) {
                        let output = < super :: ValueStructValueElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_struct_value(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                }
                *self.state = fallback
                    .take()
                    .unwrap_or(ValueStructValueValueElementTypeContentDeserializerState::Init__);
                Ok(ElementHandlerOutput::return_to_parent(event, false))
            }
            fn finish_state<R>(
                reader: &R,
                state: ValueStructValueValueElementTypeContentDeserializerState,
            ) -> Result<super::ValueStructValueValueElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                use ValueStructValueValueElementTypeContentDeserializerState as S;
                match state {
                    S::Init__ => Err(ErrorKind::MissingContent.into()),
                    S::SimpleValue(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ValueStructValueValueElementTypeContentDeserializer :: store_simple_value (& mut values , value) ? ;
                        }
                        Ok(super::ValueStructValueValueElementTypeContent::SimpleValue(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("simpleValue".into()))?,
                        ))
                    }
                    S::ArrayValue(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ValueStructValueValueElementTypeContentDeserializer::store_array_value(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::ValueStructValueValueElementTypeContent::ArrayValue(
                            values.ok_or_else(|| ErrorKind::MissingElement("arrayValue".into()))?,
                        ))
                    }
                    S::StructValue(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ValueStructValueValueElementTypeContentDeserializer :: store_struct_value (& mut values , value) ? ;
                        }
                        Ok(super::ValueStructValueValueElementTypeContent::StructValue(
                            values
                                .ok_or_else(|| ErrorKind::MissingElement("structValue".into()))?,
                        ))
                    }
                    S::Done__(data) => Ok(data),
                    S::Unknown__ => unreachable!(),
                }
            }
            fn store_simple_value(
                values: &mut Option<super::ValueSimpleValueElementType>,
                value: super::ValueSimpleValueElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"simpleValue",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_array_value(
                values: &mut Option<super::ValueArrayValueElementType>,
                value: super::ValueArrayValueElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"arrayValue",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_struct_value(
                values: &mut Option<super::ValueStructValueElementType>,
                value: super::ValueStructValueElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"structValue",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn handle_simple_value<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ValueSimpleValueElementType>,
                output: DeserializerOutput<'de, super::ValueSimpleValueElementType>,
                fallback: &mut Option<ValueStructValueValueElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state =
                                ValueStructValueValueElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            ValueStructValueValueElementTypeContentDeserializerState::SimpleValue(
                                values, None,
                            )
                        }
                        Some(
                            ValueStructValueValueElementTypeContentDeserializerState::SimpleValue(
                                _,
                                Some(deserializer),
                            ),
                        ) => ValueStructValueValueElementTypeContentDeserializerState::SimpleValue(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(
                        ValueStructValueValueElementTypeContentDeserializerState::SimpleValue(
                            _,
                            Some(deserializer),
                        ),
                    ) => {
                        let data = deserializer.finish(reader)?;
                        ValueStructValueValueElementTypeContentDeserializer::store_simple_value(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ValueStructValueValueElementTypeContentDeserializer::store_simple_value(
                            &mut values,
                            data,
                        )?;
                        let data = ValueStructValueValueElementTypeContentDeserializer :: finish_state (reader , ValueStructValueValueElementTypeContentDeserializerState :: SimpleValue (values , None)) ? ;
                        *self.state =
                            ValueStructValueValueElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            ValueStructValueValueElementTypeContentDeserializerState::SimpleValue(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_array_value<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ValueArrayValueElementType>,
                output: DeserializerOutput<'de, super::ValueArrayValueElementType>,
                fallback: &mut Option<ValueStructValueValueElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state =
                                ValueStructValueValueElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            ValueStructValueValueElementTypeContentDeserializerState::ArrayValue(
                                values, None,
                            )
                        }
                        Some(
                            ValueStructValueValueElementTypeContentDeserializerState::ArrayValue(
                                _,
                                Some(deserializer),
                            ),
                        ) => ValueStructValueValueElementTypeContentDeserializerState::ArrayValue(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(ValueStructValueValueElementTypeContentDeserializerState::ArrayValue(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        ValueStructValueValueElementTypeContentDeserializer::store_array_value(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ValueStructValueValueElementTypeContentDeserializer::store_array_value(
                            &mut values,
                            data,
                        )?;
                        let data = ValueStructValueValueElementTypeContentDeserializer :: finish_state (reader , ValueStructValueValueElementTypeContentDeserializerState :: ArrayValue (values , None)) ? ;
                        *self.state =
                            ValueStructValueValueElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            ValueStructValueValueElementTypeContentDeserializerState::ArrayValue(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_struct_value<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ValueStructValueElementType>,
                output: DeserializerOutput<'de, super::ValueStructValueElementType>,
                fallback: &mut Option<ValueStructValueValueElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state =
                                ValueStructValueValueElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            ValueStructValueValueElementTypeContentDeserializerState::StructValue(
                                values, None,
                            )
                        }
                        Some(
                            ValueStructValueValueElementTypeContentDeserializerState::StructValue(
                                _,
                                Some(deserializer),
                            ),
                        ) => ValueStructValueValueElementTypeContentDeserializerState::StructValue(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(
                        ValueStructValueValueElementTypeContentDeserializerState::StructValue(
                            _,
                            Some(deserializer),
                        ),
                    ) => {
                        let data = deserializer.finish(reader)?;
                        ValueStructValueValueElementTypeContentDeserializer::store_struct_value(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ValueStructValueValueElementTypeContentDeserializer::store_struct_value(
                            &mut values,
                            data,
                        )?;
                        let data = ValueStructValueValueElementTypeContentDeserializer :: finish_state (reader , ValueStructValueValueElementTypeContentDeserializerState :: StructValue (values , None)) ? ;
                        *self.state =
                            ValueStructValueValueElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            ValueStructValueValueElementTypeContentDeserializerState::StructValue(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ValueStructValueValueElementTypeContent>
            for Box<ValueStructValueValueElementTypeContentDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueStructValueValueElementTypeContent>
            where
                R: DeserializeReader,
            {
                let deserializer = Box::new(ValueStructValueValueElementTypeContentDeserializer {
                    state: Box::new(
                        ValueStructValueValueElementTypeContentDeserializerState::Init__,
                    ),
                });
                let mut output = deserializer.next(reader, event)?;
                output.artifact = match output.artifact {
                    DeserializerArtifact::Deserializer(x)
                        if matches!(
                            &*x.state,
                            ValueStructValueValueElementTypeContentDeserializerState::Init__
                        ) =>
                    {
                        DeserializerArtifact::None
                    }
                    artifact => artifact,
                };
                Ok(output)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ValueStructValueValueElementTypeContent>
            where
                R: DeserializeReader,
            {
                use ValueStructValueValueElementTypeContentDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::SimpleValue(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_simple_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::ArrayValue(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_array_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::StructValue(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_struct_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (state, event @ Event::End(_)) => {
                            return Ok (DeserializerOutput { artifact : DeserializerArtifact :: Data (ValueStructValueValueElementTypeContentDeserializer :: finish_state (reader , state) ?) , event : DeserializerEvent :: Continue (event) , allow_any : false , }) ;
                        }
                        (S::Init__, event) => {
                            match self.find_suitable(reader, event, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::SimpleValue(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"simpleValue",
                                false,
                            )?;
                            match self.handle_simple_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::ArrayValue(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"arrayValue",
                                false,
                            )?;
                            match self.handle_array_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::StructValue(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"structValue",
                                false,
                            )?;
                            match self.handle_struct_value(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (s @ S::Done__(_), event) => {
                            *self.state = s;
                            break (DeserializerEvent::Continue(event), false);
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = if matches!(&*self.state, S::Done__(_)) {
                    DeserializerArtifact::Data(self.finish(reader)?)
                } else {
                    DeserializerArtifact::Deserializer(self)
                };
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                self,
                reader: &R,
            ) -> Result<super::ValueStructValueValueElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                ValueStructValueValueElementTypeContentDeserializer::finish_state(
                    reader,
                    *self.state,
                )
            }
        }
        #[derive(Debug)]
        pub struct ActionBlockActionElementTypeDeserializer {
            local_id: ::core::primitive::u64,
            qualifier: super::ActionBlockActionQualifierType,
            width: Option<::core::primitive::f64>,
            height: Option<::core::primitive::f64>,
            duration: Option<::std::string::String>,
            indicator: Option<::std::string::String>,
            execution_order_id: Option<::core::primitive::u64>,
            global_id: Option<::std::string::String>,
            rel_position: Option<super::PositionType>,
            reference: Option<super::ActionBlockActionReferenceElementType>,
            inline: Option<super::BodyType>,
            connection_point_out: Option<super::ConnectionPointOutType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<ActionBlockActionElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ActionBlockActionElementTypeDeserializerState {
            Init__ , RelPosition (Option << super :: PositionType as WithDeserializer > :: Deserializer >) , Reference (Option << super :: ActionBlockActionReferenceElementType as WithDeserializer > :: Deserializer >) , Inline (Option << super :: BodyType as WithDeserializer > :: Deserializer >) , ConnectionPointOut (Option << super :: ConnectionPointOutType as WithDeserializer > :: Deserializer >) , AddData (Option << super :: AddDataType as WithDeserializer > :: Deserializer >) , Documentation (Option << super :: FormattedTextType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl ActionBlockActionElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut local_id: Option<::core::primitive::u64> = None;
                let mut qualifier: Option<super::ActionBlockActionQualifierType> = None;
                let mut width: Option<::core::primitive::f64> = None;
                let mut height: Option<::core::primitive::f64> = None;
                let mut duration: Option<::std::string::String> = None;
                let mut indicator: Option<::std::string::String> = None;
                let mut execution_order_id: Option<::core::primitive::u64> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"localId")
                    ) {
                        reader.read_attrib(&mut local_id, b"localId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"qualifier")
                    ) {
                        reader.read_attrib(&mut qualifier, b"qualifier", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"width")
                    ) {
                        reader.read_attrib(&mut width, b"width", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"height")
                    ) {
                        reader.read_attrib(&mut height, b"height", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"duration")
                    ) {
                        reader.read_attrib(&mut duration, b"duration", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"indicator")
                    ) {
                        reader.read_attrib(&mut indicator, b"indicator", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"executionOrderId")
                    ) {
                        reader.read_attrib(
                            &mut execution_order_id,
                            b"executionOrderId",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    local_id: local_id.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("localId".into()))
                    })?,
                    qualifier: qualifier
                        .unwrap_or_else(super::ActionBlockActionElementType::default_qualifier),
                    width: width,
                    height: height,
                    duration: duration,
                    indicator: indicator,
                    execution_order_id: execution_order_id,
                    global_id: global_id,
                    rel_position: None,
                    reference: None,
                    inline: None,
                    connection_point_out: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(ActionBlockActionElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ActionBlockActionElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ActionBlockActionElementTypeDeserializerState as S;
                match state {
                    S::RelPosition(Some(deserializer)) => {
                        self.store_rel_position(deserializer.finish(reader)?)?
                    }
                    S::Reference(Some(deserializer)) => {
                        self.store_reference(deserializer.finish(reader)?)?
                    }
                    S::Inline(Some(deserializer)) => {
                        self.store_inline(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointOut(Some(deserializer)) => {
                        self.store_connection_point_out(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_rel_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.rel_position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"relPosition",
                    )))?;
                }
                self.rel_position = Some(value);
                Ok(())
            }
            fn store_reference(
                &mut self,
                value: super::ActionBlockActionReferenceElementType,
            ) -> Result<(), Error> {
                if self.reference.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"reference",
                    )))?;
                }
                self.reference = Some(value);
                Ok(())
            }
            fn store_inline(&mut self, value: super::BodyType) -> Result<(), Error> {
                if self.inline.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"inline",
                    )))?;
                }
                self.inline = Some(value);
                Ok(())
            }
            fn store_connection_point_out(
                &mut self,
                value: super::ConnectionPointOutType,
            ) -> Result<(), Error> {
                if self.connection_point_out.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointOut",
                    )))?;
                }
                self.connection_point_out = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_rel_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<ActionBlockActionElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.rel_position.is_some() {
                        fallback.get_or_insert(
                            ActionBlockActionElementTypeDeserializerState::RelPosition(None),
                        );
                        *self.state =
                            ActionBlockActionElementTypeDeserializerState::Reference(None);
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state =
                            ActionBlockActionElementTypeDeserializerState::RelPosition(None);
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_rel_position(data)?;
                        *self.state =
                            ActionBlockActionElementTypeDeserializerState::Reference(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ActionBlockActionElementTypeDeserializerState::RelPosition(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    ActionBlockActionElementTypeDeserializerState::Reference(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ActionBlockActionElementTypeDeserializerState::RelPosition(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_reference<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ActionBlockActionReferenceElementType>,
                fallback: &mut Option<ActionBlockActionElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ActionBlockActionElementTypeDeserializerState::Reference(None),
                    );
                    *self.state = ActionBlockActionElementTypeDeserializerState::Inline(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_reference(data)?;
                        *self.state = ActionBlockActionElementTypeDeserializerState::Inline(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ActionBlockActionElementTypeDeserializerState::Reference(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    ActionBlockActionElementTypeDeserializerState::Inline(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ActionBlockActionElementTypeDeserializerState::Reference(Some(
                                        deserializer,
                                    ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_inline<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::BodyType>,
                fallback: &mut Option<ActionBlockActionElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(ActionBlockActionElementTypeDeserializerState::Inline(None));
                    *self.state =
                        ActionBlockActionElementTypeDeserializerState::ConnectionPointOut(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_inline(data)?;
                        *self.state =
                            ActionBlockActionElementTypeDeserializerState::ConnectionPointOut(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ActionBlockActionElementTypeDeserializerState::Inline(Some(
                                        deserializer,
                                    )),
                                );
                                * self . state = ActionBlockActionElementTypeDeserializerState :: ConnectionPointOut (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ActionBlockActionElementTypeDeserializerState::Inline(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_out<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointOutType>,
                fallback: &mut Option<ActionBlockActionElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ActionBlockActionElementTypeDeserializerState::ConnectionPointOut(None),
                    );
                    *self.state = ActionBlockActionElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_out(data)?;
                        *self.state = ActionBlockActionElementTypeDeserializerState::AddData(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ActionBlockActionElementTypeDeserializerState :: ConnectionPointOut (Some (deserializer))) ;
                                *self.state =
                                    ActionBlockActionElementTypeDeserializerState::AddData(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ActionBlockActionElementTypeDeserializerState :: ConnectionPointOut (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<ActionBlockActionElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(ActionBlockActionElementTypeDeserializerState::AddData(
                        None,
                    ));
                    *self.state =
                        ActionBlockActionElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state =
                            ActionBlockActionElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ActionBlockActionElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    ActionBlockActionElementTypeDeserializerState::Documentation(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ActionBlockActionElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<ActionBlockActionElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ActionBlockActionElementTypeDeserializerState::Documentation(None),
                    );
                    *self.state = ActionBlockActionElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = ActionBlockActionElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ActionBlockActionElementTypeDeserializerState::Documentation(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state = ActionBlockActionElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ActionBlockActionElementTypeDeserializerState::Documentation(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ActionBlockActionElementType>
            for Box<ActionBlockActionElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ActionBlockActionElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ActionBlockActionElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ActionBlockActionElementType>
            where
                R: DeserializeReader,
            {
                use ActionBlockActionElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::RelPosition(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_rel_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Reference(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_reference(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Inline(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_inline(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointOut(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                ActionBlockActionElementTypeDeserializerState::RelPosition(None);
                            event
                        }
                        (S::RelPosition(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"relPosition",
                                false,
                            )?;
                            match self.handle_rel_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Reference(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"reference",
                                false,
                            )?;
                            match self.handle_reference(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Inline(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"inline",
                                true,
                            )?;
                            match self.handle_inline(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointOut(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointOut",
                                false,
                            )?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::ActionBlockActionElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ActionBlockActionElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ActionBlockActionElementType {
                    local_id: self.local_id,
                    qualifier: self.qualifier,
                    width: self.width,
                    height: self.height,
                    duration: self.duration,
                    indicator: self.indicator,
                    execution_order_id: self.execution_order_id,
                    global_id: self.global_id,
                    rel_position: self
                        .rel_position
                        .ok_or_else(|| ErrorKind::MissingElement("relPosition".into()))?,
                    reference: self.reference,
                    inline: self.inline,
                    connection_point_out: self.connection_point_out,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct BlockInputVariablesElementTypeDeserializer {
            variable: Vec<super::BlockInputVariablesVariableElementType>,
            state: Box<BlockInputVariablesElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum BlockInputVariablesElementTypeDeserializerState {
            Init__ , Variable (Option << super :: BlockInputVariablesVariableElementType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl BlockInputVariablesElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    variable: Vec::new(),
                    state: Box::new(BlockInputVariablesElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: BlockInputVariablesElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use BlockInputVariablesElementTypeDeserializerState as S;
                match state {
                    S::Variable(Some(deserializer)) => {
                        self.store_variable(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_variable(
                &mut self,
                value: super::BlockInputVariablesVariableElementType,
            ) -> Result<(), Error> {
                self.variable.push(value);
                Ok(())
            }
            fn handle_variable<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::BlockInputVariablesVariableElementType>,
                fallback: &mut Option<BlockInputVariablesElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        BlockInputVariablesElementTypeDeserializerState::Variable(None),
                    );
                    *self.state = BlockInputVariablesElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_variable(data)?;
                        *self.state =
                            BlockInputVariablesElementTypeDeserializerState::Variable(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    BlockInputVariablesElementTypeDeserializerState::Variable(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    BlockInputVariablesElementTypeDeserializerState::Variable(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    BlockInputVariablesElementTypeDeserializerState::Variable(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::BlockInputVariablesElementType>
            for Box<BlockInputVariablesElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BlockInputVariablesElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    BlockInputVariablesElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BlockInputVariablesElementType>
            where
                R: DeserializeReader,
            {
                use BlockInputVariablesElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Variable(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                BlockInputVariablesElementTypeDeserializerState::Variable(None);
                            event
                        }
                        (S::Variable(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"variable",
                                true,
                            )?;
                            match self.handle_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::BlockInputVariablesElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    BlockInputVariablesElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::BlockInputVariablesElementType {
                    variable: self.variable,
                })
            }
        }
        #[derive(Debug)]
        pub struct BlockInOutVariablesElementTypeDeserializer {
            variable: Vec<super::BlockInOutVariablesVariableElementType>,
            state: Box<BlockInOutVariablesElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum BlockInOutVariablesElementTypeDeserializerState {
            Init__ , Variable (Option << super :: BlockInOutVariablesVariableElementType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl BlockInOutVariablesElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    variable: Vec::new(),
                    state: Box::new(BlockInOutVariablesElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: BlockInOutVariablesElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use BlockInOutVariablesElementTypeDeserializerState as S;
                match state {
                    S::Variable(Some(deserializer)) => {
                        self.store_variable(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_variable(
                &mut self,
                value: super::BlockInOutVariablesVariableElementType,
            ) -> Result<(), Error> {
                self.variable.push(value);
                Ok(())
            }
            fn handle_variable<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::BlockInOutVariablesVariableElementType>,
                fallback: &mut Option<BlockInOutVariablesElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        BlockInOutVariablesElementTypeDeserializerState::Variable(None),
                    );
                    *self.state = BlockInOutVariablesElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_variable(data)?;
                        *self.state =
                            BlockInOutVariablesElementTypeDeserializerState::Variable(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    BlockInOutVariablesElementTypeDeserializerState::Variable(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    BlockInOutVariablesElementTypeDeserializerState::Variable(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    BlockInOutVariablesElementTypeDeserializerState::Variable(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::BlockInOutVariablesElementType>
            for Box<BlockInOutVariablesElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BlockInOutVariablesElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    BlockInOutVariablesElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BlockInOutVariablesElementType>
            where
                R: DeserializeReader,
            {
                use BlockInOutVariablesElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Variable(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                BlockInOutVariablesElementTypeDeserializerState::Variable(None);
                            event
                        }
                        (S::Variable(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"variable",
                                true,
                            )?;
                            match self.handle_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::BlockInOutVariablesElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    BlockInOutVariablesElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::BlockInOutVariablesElementType {
                    variable: self.variable,
                })
            }
        }
        #[derive(Debug)]
        pub struct BlockOutputVariablesElementTypeDeserializer {
            variable: Vec<super::BlockOutputVariablesVariableElementType>,
            state: Box<BlockOutputVariablesElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum BlockOutputVariablesElementTypeDeserializerState {
            Init__ , Variable (Option << super :: BlockOutputVariablesVariableElementType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl BlockOutputVariablesElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    variable: Vec::new(),
                    state: Box::new(BlockOutputVariablesElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: BlockOutputVariablesElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use BlockOutputVariablesElementTypeDeserializerState as S;
                match state {
                    S::Variable(Some(deserializer)) => {
                        self.store_variable(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_variable(
                &mut self,
                value: super::BlockOutputVariablesVariableElementType,
            ) -> Result<(), Error> {
                self.variable.push(value);
                Ok(())
            }
            fn handle_variable<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::BlockOutputVariablesVariableElementType>,
                fallback: &mut Option<BlockOutputVariablesElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        BlockOutputVariablesElementTypeDeserializerState::Variable(None),
                    );
                    *self.state = BlockOutputVariablesElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_variable(data)?;
                        *self.state =
                            BlockOutputVariablesElementTypeDeserializerState::Variable(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    BlockOutputVariablesElementTypeDeserializerState::Variable(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    BlockOutputVariablesElementTypeDeserializerState::Variable(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    BlockOutputVariablesElementTypeDeserializerState::Variable(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::BlockOutputVariablesElementType>
            for Box<BlockOutputVariablesElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BlockOutputVariablesElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    BlockOutputVariablesElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BlockOutputVariablesElementType>
            where
                R: DeserializeReader,
            {
                use BlockOutputVariablesElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Variable(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                BlockOutputVariablesElementTypeDeserializerState::Variable(None);
                            event
                        }
                        (S::Variable(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"variable",
                                false,
                            )?;
                            match self.handle_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::BlockOutputVariablesElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    BlockOutputVariablesElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::BlockOutputVariablesElementType {
                    variable: self.variable,
                })
            }
        }
        #[derive(Debug)]
        pub struct LeftPowerRailConnectionPointOutElementTypeDeserializer {
            global_id: Option<::std::string::String>,
            formal_parameter: ::std::string::String,
            rel_position: Option<super::PositionType>,
            expression: Option<::std::string::String>,
            add_data: Option<super::AddDataType>,
            state: Box<LeftPowerRailConnectionPointOutElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum LeftPowerRailConnectionPointOutElementTypeDeserializerState {
            Init__,
            RelPosition(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            Expression(Option<<::std::string::String as WithDeserializer>::Deserializer>),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl LeftPowerRailConnectionPointOutElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut global_id: Option<::std::string::String> = None;
                let mut formal_parameter: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"formalParameter")
                    ) {
                        reader.read_attrib(
                            &mut formal_parameter,
                            b"formalParameter",
                            &attrib.value,
                        )?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    global_id: global_id,
                    formal_parameter: formal_parameter.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("formalParameter".into()))
                    })?,
                    rel_position: None,
                    expression: None,
                    add_data: None,
                    state: Box::new(
                        LeftPowerRailConnectionPointOutElementTypeDeserializerState::Init__,
                    ),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: LeftPowerRailConnectionPointOutElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use LeftPowerRailConnectionPointOutElementTypeDeserializerState as S;
                match state {
                    S::RelPosition(Some(deserializer)) => {
                        self.store_rel_position(deserializer.finish(reader)?)?
                    }
                    S::Expression(Some(deserializer)) => {
                        self.store_expression(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_rel_position(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.rel_position.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"relPosition",
                    )))?;
                }
                self.rel_position = Some(value);
                Ok(())
            }
            fn store_expression(&mut self, value: ::std::string::String) -> Result<(), Error> {
                if self.expression.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"expression",
                    )))?;
                }
                self.expression = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn handle_rel_position<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<LeftPowerRailConnectionPointOutElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        LeftPowerRailConnectionPointOutElementTypeDeserializerState::RelPosition(
                            None,
                        ),
                    );
                    *self.state =
                        LeftPowerRailConnectionPointOutElementTypeDeserializerState::Expression(
                            None,
                        );
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_rel_position(data)?;
                        *self.state =
                            LeftPowerRailConnectionPointOutElementTypeDeserializerState::Expression(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (LeftPowerRailConnectionPointOutElementTypeDeserializerState :: RelPosition (Some (deserializer))) ;
                                * self . state = LeftPowerRailConnectionPointOutElementTypeDeserializerState :: Expression (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = LeftPowerRailConnectionPointOutElementTypeDeserializerState :: RelPosition (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_expression<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, ::std::string::String>,
                fallback: &mut Option<LeftPowerRailConnectionPointOutElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        LeftPowerRailConnectionPointOutElementTypeDeserializerState::Expression(
                            None,
                        ),
                    );
                    *self.state =
                        LeftPowerRailConnectionPointOutElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_expression(data)?;
                        *self.state =
                            LeftPowerRailConnectionPointOutElementTypeDeserializerState::AddData(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (LeftPowerRailConnectionPointOutElementTypeDeserializerState :: Expression (Some (deserializer))) ;
                                * self . state = LeftPowerRailConnectionPointOutElementTypeDeserializerState :: AddData (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = LeftPowerRailConnectionPointOutElementTypeDeserializerState :: Expression (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<LeftPowerRailConnectionPointOutElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        LeftPowerRailConnectionPointOutElementTypeDeserializerState::AddData(None),
                    );
                    *self.state =
                        LeftPowerRailConnectionPointOutElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state =
                            LeftPowerRailConnectionPointOutElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (LeftPowerRailConnectionPointOutElementTypeDeserializerState :: AddData (Some (deserializer))) ;
                                * self . state = LeftPowerRailConnectionPointOutElementTypeDeserializerState :: Done__ ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = LeftPowerRailConnectionPointOutElementTypeDeserializerState :: AddData (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::LeftPowerRailConnectionPointOutElementType>
            for Box<LeftPowerRailConnectionPointOutElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::LeftPowerRailConnectionPointOutElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    LeftPowerRailConnectionPointOutElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::LeftPowerRailConnectionPointOutElementType>
            where
                R: DeserializeReader,
            {
                use LeftPowerRailConnectionPointOutElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::RelPosition(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_rel_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Expression(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_expression(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            * self . state = LeftPowerRailConnectionPointOutElementTypeDeserializerState :: RelPosition (None) ;
                            event
                        }
                        (S::RelPosition(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"relPosition",
                                false,
                            )?;
                            match self.handle_rel_position(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Expression(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"expression",
                                false,
                            )?;
                            match self.handle_expression(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::LeftPowerRailConnectionPointOutElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    LeftPowerRailConnectionPointOutElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::LeftPowerRailConnectionPointOutElementType {
                    global_id: self.global_id,
                    formal_parameter: self.formal_parameter,
                    rel_position: self.rel_position,
                    expression: self.expression,
                    add_data: self.add_data,
                })
            }
        }
        #[derive(Debug)]
        pub struct TransitionConditionElementTypeDeserializer {
            negated: ::core::primitive::bool,
            content: Option<super::TransitionConditionElementTypeContent>,
            state: Box<TransitionConditionElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum TransitionConditionElementTypeDeserializerState {
            Init__,
            Next__,
            Content__(
                <super::TransitionConditionElementTypeContent as WithDeserializer>::Deserializer,
            ),
            Unknown__,
        }
        impl TransitionConditionElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut negated: Option<::core::primitive::bool> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"negated")
                    ) {
                        reader.read_attrib(&mut negated, b"negated", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    negated: negated
                        .unwrap_or_else(super::TransitionConditionElementType::default_negated),
                    content: None,
                    state: Box::new(TransitionConditionElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: TransitionConditionElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                if let TransitionConditionElementTypeDeserializerState::Content__(deserializer) =
                    state
                {
                    self.store_content(deserializer.finish(reader)?)?;
                }
                Ok(())
            }
            fn store_content(
                &mut self,
                value: super::TransitionConditionElementTypeContent,
            ) -> Result<(), Error> {
                if self.content.is_some() {
                    Err(ErrorKind::DuplicateContent)?;
                }
                self.content = Some(value);
                Ok(())
            }
            fn handle_content<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::TransitionConditionElementTypeContent>,
                fallback: &mut Option<TransitionConditionElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = fallback
                        .take()
                        .unwrap_or(TransitionConditionElementTypeDeserializerState::Next__);
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_content(data)?;
                        *self.state = TransitionConditionElementTypeDeserializerState::Next__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state = TransitionConditionElementTypeDeserializerState::Content__(
                            deserializer,
                        );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::TransitionConditionElementType>
            for Box<TransitionConditionElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::TransitionConditionElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    TransitionConditionElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::TransitionConditionElementType>
            where
                R: DeserializeReader,
            {
                use TransitionConditionElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Content__(deserializer), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (_, Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (state @ (S::Init__ | S::Next__), event) => {
                            fallback.get_or_insert(state);
                            let output = < super :: TransitionConditionElementTypeContent as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = DeserializerArtifact::Deserializer(self);
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::TransitionConditionElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    TransitionConditionElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::TransitionConditionElementType {
                    negated: self.negated,
                    content: self.content.ok_or_else(|| ErrorKind::MissingContent)?,
                })
            }
        }
        #[derive(Debug)]
        pub struct TransitionConditionElementTypeContentDeserializer {
            state: Box<TransitionConditionElementTypeContentDeserializerState>,
        }
        #[derive(Debug)]
        pub enum TransitionConditionElementTypeContentDeserializerState {
            Init__ , Reference (Option < super :: ActionBlockActionReferenceElementType > , Option << super :: ActionBlockActionReferenceElementType as WithDeserializer > :: Deserializer >) , ConnectionPointIn (Option < super :: ConnectionPointInType > , Option << super :: ConnectionPointInType as WithDeserializer > :: Deserializer >) , Inline (Option < super :: TransitionConditionInlineElementType > , Option << super :: TransitionConditionInlineElementType as WithDeserializer > :: Deserializer >) , Done__ (super :: TransitionConditionElementTypeContent) , Unknown__ , }
        impl TransitionConditionElementTypeContentDeserializer {
            fn find_suitable<'de, R>(
                &mut self,
                reader: &R,
                event: Event<'de>,
                fallback: &mut Option<TransitionConditionElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                if let Event::Start(x) | Event::Empty(x) = &event {
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"reference")
                    ) {
                        let output = < super :: ActionBlockActionReferenceElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_reference(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"connectionPointIn")
                    ) {
                        let output =
                            <super::ConnectionPointInType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_connection_point_in(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"inline")
                    ) {
                        let output = < super :: TransitionConditionInlineElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_inline(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                }
                *self.state = fallback
                    .take()
                    .unwrap_or(TransitionConditionElementTypeContentDeserializerState::Init__);
                Ok(ElementHandlerOutput::return_to_parent(event, false))
            }
            fn finish_state<R>(
                reader: &R,
                state: TransitionConditionElementTypeContentDeserializerState,
            ) -> Result<super::TransitionConditionElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                use TransitionConditionElementTypeContentDeserializerState as S;
                match state {
                    S::Init__ => Err(ErrorKind::MissingContent.into()),
                    S::Reference(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            TransitionConditionElementTypeContentDeserializer::store_reference(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::TransitionConditionElementTypeContent::Reference(
                            values.ok_or_else(|| ErrorKind::MissingElement("reference".into()))?,
                        ))
                    }
                    S::ConnectionPointIn(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            TransitionConditionElementTypeContentDeserializer :: store_connection_point_in (& mut values , value) ? ;
                        }
                        Ok(
                            super::TransitionConditionElementTypeContent::ConnectionPointIn(
                                values.ok_or_else(|| {
                                    ErrorKind::MissingElement("connectionPointIn".into())
                                })?,
                            ),
                        )
                    }
                    S::Inline(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            TransitionConditionElementTypeContentDeserializer::store_inline(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::TransitionConditionElementTypeContent::Inline(
                            values.ok_or_else(|| ErrorKind::MissingElement("inline".into()))?,
                        ))
                    }
                    S::Done__(data) => Ok(data),
                    S::Unknown__ => unreachable!(),
                }
            }
            fn store_reference(
                values: &mut Option<super::ActionBlockActionReferenceElementType>,
                value: super::ActionBlockActionReferenceElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"reference",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_connection_point_in(
                values: &mut Option<super::ConnectionPointInType>,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointIn",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_inline(
                values: &mut Option<super::TransitionConditionInlineElementType>,
                value: super::TransitionConditionInlineElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"inline",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn handle_reference<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ActionBlockActionReferenceElementType>,
                output: DeserializerOutput<'de, super::ActionBlockActionReferenceElementType>,
                fallback: &mut Option<TransitionConditionElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state =
                                TransitionConditionElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => TransitionConditionElementTypeContentDeserializerState::Reference(
                            values, None,
                        ),
                        Some(
                            TransitionConditionElementTypeContentDeserializerState::Reference(
                                _,
                                Some(deserializer),
                            ),
                        ) => TransitionConditionElementTypeContentDeserializerState::Reference(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(TransitionConditionElementTypeContentDeserializerState::Reference(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        TransitionConditionElementTypeContentDeserializer::store_reference(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        TransitionConditionElementTypeContentDeserializer::store_reference(
                            &mut values,
                            data,
                        )?;
                        let data = TransitionConditionElementTypeContentDeserializer::finish_state(
                            reader,
                            TransitionConditionElementTypeContentDeserializerState::Reference(
                                values, None,
                            ),
                        )?;
                        *self.state =
                            TransitionConditionElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            TransitionConditionElementTypeContentDeserializerState::Reference(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ConnectionPointInType>,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<TransitionConditionElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    * self . state = match fallback . take () { None if values . is_none () => { * self . state = TransitionConditionElementTypeContentDeserializerState :: Init__ ; return Ok (ElementHandlerOutput :: from_event (event , allow_any)) ; } , None => TransitionConditionElementTypeContentDeserializerState :: ConnectionPointIn (values , None) , Some (TransitionConditionElementTypeContentDeserializerState :: ConnectionPointIn (_ , Some (deserializer))) => TransitionConditionElementTypeContentDeserializerState :: ConnectionPointIn (values , Some (deserializer)) , _ => unreachable ! () , } ;
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(
                        TransitionConditionElementTypeContentDeserializerState::ConnectionPointIn(
                            _,
                            Some(deserializer),
                        ),
                    ) => {
                        let data = deserializer.finish(reader)?;
                        TransitionConditionElementTypeContentDeserializer :: store_connection_point_in (& mut values , data) ? ;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        TransitionConditionElementTypeContentDeserializer :: store_connection_point_in (& mut values , data) ? ;
                        let data = TransitionConditionElementTypeContentDeserializer :: finish_state (reader , TransitionConditionElementTypeContentDeserializerState :: ConnectionPointIn (values , None)) ? ;
                        *self.state =
                            TransitionConditionElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        * self . state = TransitionConditionElementTypeContentDeserializerState :: ConnectionPointIn (values , Some (deserializer)) ;
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_inline<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::TransitionConditionInlineElementType>,
                output: DeserializerOutput<'de, super::TransitionConditionInlineElementType>,
                fallback: &mut Option<TransitionConditionElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            *self.state =
                                TransitionConditionElementTypeContentDeserializerState::Init__;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => TransitionConditionElementTypeContentDeserializerState::Inline(
                            values, None,
                        ),
                        Some(TransitionConditionElementTypeContentDeserializerState::Inline(
                            _,
                            Some(deserializer),
                        )) => TransitionConditionElementTypeContentDeserializerState::Inline(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(TransitionConditionElementTypeContentDeserializerState::Inline(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        TransitionConditionElementTypeContentDeserializer::store_inline(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        TransitionConditionElementTypeContentDeserializer::store_inline(
                            &mut values,
                            data,
                        )?;
                        let data = TransitionConditionElementTypeContentDeserializer::finish_state(
                            reader,
                            TransitionConditionElementTypeContentDeserializerState::Inline(
                                values, None,
                            ),
                        )?;
                        *self.state =
                            TransitionConditionElementTypeContentDeserializerState::Done__(data);
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            TransitionConditionElementTypeContentDeserializerState::Inline(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::TransitionConditionElementTypeContent>
            for Box<TransitionConditionElementTypeContentDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::TransitionConditionElementTypeContent>
            where
                R: DeserializeReader,
            {
                let deserializer = Box::new(TransitionConditionElementTypeContentDeserializer {
                    state: Box::new(TransitionConditionElementTypeContentDeserializerState::Init__),
                });
                let mut output = deserializer.next(reader, event)?;
                output.artifact = match output.artifact {
                    DeserializerArtifact::Deserializer(x)
                        if matches!(
                            &*x.state,
                            TransitionConditionElementTypeContentDeserializerState::Init__
                        ) =>
                    {
                        DeserializerArtifact::None
                    }
                    artifact => artifact,
                };
                Ok(output)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::TransitionConditionElementTypeContent>
            where
                R: DeserializeReader,
            {
                use TransitionConditionElementTypeContentDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Reference(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_reference(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::ConnectionPointIn(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Inline(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_inline(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (state, event @ Event::End(_)) => {
                            return Ok (DeserializerOutput { artifact : DeserializerArtifact :: Data (TransitionConditionElementTypeContentDeserializer :: finish_state (reader , state) ?) , event : DeserializerEvent :: Continue (event) , allow_any : false , }) ;
                        }
                        (S::Init__, event) => {
                            match self.find_suitable(reader, event, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Reference(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"reference",
                                false,
                            )?;
                            match self.handle_reference(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::ConnectionPointIn(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Inline(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"inline",
                                true,
                            )?;
                            match self.handle_inline(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (s @ S::Done__(_), event) => {
                            *self.state = s;
                            break (DeserializerEvent::Continue(event), false);
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = if matches!(&*self.state, S::Done__(_)) {
                    DeserializerArtifact::Data(self.finish(reader)?)
                } else {
                    DeserializerArtifact::Deserializer(self)
                };
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                self,
                reader: &R,
            ) -> Result<super::TransitionConditionElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                TransitionConditionElementTypeContentDeserializer::finish_state(reader, *self.state)
            }
        }
        #[derive(Debug)]
        pub struct SelectionConvergenceConnectionPointInElementTypeDeserializer {
            global_id: Option<::std::string::String>,
            content: Vec<super::SelectionConvergenceConnectionPointInElementTypeContent>,
            state: Box<SelectionConvergenceConnectionPointInElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum SelectionConvergenceConnectionPointInElementTypeDeserializerState {
            Init__ , Next__ , Content__ (< super :: SelectionConvergenceConnectionPointInElementTypeContent as WithDeserializer > :: Deserializer) , Unknown__ , }
        impl SelectionConvergenceConnectionPointInElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    global_id: global_id,
                    content: Vec::new(),
                    state: Box::new(
                        SelectionConvergenceConnectionPointInElementTypeDeserializerState::Init__,
                    ),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: SelectionConvergenceConnectionPointInElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                if let SelectionConvergenceConnectionPointInElementTypeDeserializerState :: Content__ (deserializer) = state { self . store_content (deserializer . finish (reader) ?) ? ; }
                Ok(())
            }
            fn store_content(
                &mut self,
                value: super::SelectionConvergenceConnectionPointInElementTypeContent,
            ) -> Result<(), Error> {
                self.content.push(value);
                Ok(())
            }
            fn handle_content<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<
                    'de,
                    super::SelectionConvergenceConnectionPointInElementTypeContent,
                >,
                fallback: &mut Option<
                    SelectionConvergenceConnectionPointInElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = fallback.take().unwrap_or(
                        SelectionConvergenceConnectionPointInElementTypeDeserializerState::Next__,
                    );
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_content(data)?;
                        * self . state = SelectionConvergenceConnectionPointInElementTypeDeserializerState :: Next__ ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = SelectionConvergenceConnectionPointInElementTypeDeserializerState :: Content__ (deserializer) ;
                            }
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (SelectionConvergenceConnectionPointInElementTypeDeserializerState :: Content__ (deserializer)) ;
                                * self . state = SelectionConvergenceConnectionPointInElementTypeDeserializerState :: Next__ ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::SelectionConvergenceConnectionPointInElementType>
            for Box<SelectionConvergenceConnectionPointInElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::SelectionConvergenceConnectionPointInElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    SelectionConvergenceConnectionPointInElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::SelectionConvergenceConnectionPointInElementType>
            where
                R: DeserializeReader,
            {
                use SelectionConvergenceConnectionPointInElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Content__(deserializer), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (_, Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (state @ (S::Init__ | S::Next__), event) => {
                            fallback.get_or_insert(state);
                            let output = < super :: SelectionConvergenceConnectionPointInElementTypeContent as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = DeserializerArtifact::Deserializer(self);
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::SelectionConvergenceConnectionPointInElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    SelectionConvergenceConnectionPointInElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::SelectionConvergenceConnectionPointInElementType {
                    global_id: self.global_id,
                    content: self.content,
                })
            }
        }
        #[derive(Debug)]
        pub struct SelectionConvergenceConnectionPointInElementTypeContentDeserializer {
            state: Box<SelectionConvergenceConnectionPointInElementTypeContentDeserializerState>,
        }
        #[derive(Debug)]
        pub enum SelectionConvergenceConnectionPointInElementTypeContentDeserializerState {
            Init__,
            RelPosition(
                Option<super::PositionType>,
                Option<<super::PositionType as WithDeserializer>::Deserializer>,
            ),
            Connection(
                Option<super::ConnectionType>,
                Option<<super::ConnectionType as WithDeserializer>::Deserializer>,
            ),
            Expression(
                Option<::std::string::String>,
                Option<<::std::string::String as WithDeserializer>::Deserializer>,
            ),
            AddData(
                Option<super::AddDataType>,
                Option<<super::AddDataType as WithDeserializer>::Deserializer>,
            ),
            Done__(super::SelectionConvergenceConnectionPointInElementTypeContent),
            Unknown__,
        }
        impl SelectionConvergenceConnectionPointInElementTypeContentDeserializer {
            fn find_suitable<'de, R>(
                &mut self,
                reader: &R,
                event: Event<'de>,
                fallback: &mut Option<
                    SelectionConvergenceConnectionPointInElementTypeContentDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                if let Event::Start(x) | Event::Empty(x) = &event {
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"relPosition")
                    ) {
                        let output = <super::PositionType as WithDeserializer>::Deserializer::init(
                            reader, event,
                        )?;
                        return self.handle_rel_position(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"connection")
                    ) {
                        let output =
                            <super::ConnectionType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_connection(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"expression")
                    ) {
                        let output =
                            <::std::string::String as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_expression(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"addData")
                    ) {
                        let output = <super::AddDataType as WithDeserializer>::Deserializer::init(
                            reader, event,
                        )?;
                        return self.handle_add_data(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                }
                * self . state = fallback . take () . unwrap_or (SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Init__) ;
                Ok(ElementHandlerOutput::return_to_parent(event, false))
            }
            fn finish_state<R>(
                reader: &R,
                state: SelectionConvergenceConnectionPointInElementTypeContentDeserializerState,
            ) -> Result<super::SelectionConvergenceConnectionPointInElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                use SelectionConvergenceConnectionPointInElementTypeContentDeserializerState as S;
                match state {
                    S::Init__ => Err(ErrorKind::MissingContent.into()),
                    S::RelPosition(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            SelectionConvergenceConnectionPointInElementTypeContentDeserializer :: store_rel_position (& mut values , value) ? ;
                        }
                        Ok (super :: SelectionConvergenceConnectionPointInElementTypeContent :: RelPosition (values . ok_or_else (|| ErrorKind :: MissingElement ("relPosition" . into ())) ?))
                    }
                    S::Connection(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            SelectionConvergenceConnectionPointInElementTypeContentDeserializer :: store_connection (& mut values , value) ? ;
                        }
                        Ok (super :: SelectionConvergenceConnectionPointInElementTypeContent :: Connection (values . ok_or_else (|| ErrorKind :: MissingElement ("connection" . into ())) ?))
                    }
                    S::Expression(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            SelectionConvergenceConnectionPointInElementTypeContentDeserializer :: store_expression (& mut values , value) ? ;
                        }
                        Ok (super :: SelectionConvergenceConnectionPointInElementTypeContent :: Expression (values . ok_or_else (|| ErrorKind :: MissingElement ("expression" . into ())) ?))
                    }
                    S::AddData(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            SelectionConvergenceConnectionPointInElementTypeContentDeserializer :: store_add_data (& mut values , value) ? ;
                        }
                        Ok(
                            super::SelectionConvergenceConnectionPointInElementTypeContent::AddData(
                                values
                                    .ok_or_else(|| ErrorKind::MissingElement("addData".into()))?,
                            ),
                        )
                    }
                    S::Done__(data) => Ok(data),
                    S::Unknown__ => unreachable!(),
                }
            }
            fn store_rel_position(
                values: &mut Option<super::PositionType>,
                value: super::PositionType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"relPosition",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_connection(
                values: &mut Option<super::ConnectionType>,
                value: super::ConnectionType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connection",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_expression(
                values: &mut Option<::std::string::String>,
                value: ::std::string::String,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"expression",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_add_data(
                values: &mut Option<super::AddDataType>,
                value: super::AddDataType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn handle_rel_position<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::PositionType>,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<
                    SelectionConvergenceConnectionPointInElementTypeContentDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    * self . state = match fallback . take () { None if values . is_none () => { * self . state = SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Init__ ; return Ok (ElementHandlerOutput :: from_event (event , allow_any)) ; } , None => SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: RelPosition (values , None) , Some (SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: RelPosition (_ , Some (deserializer))) => SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: RelPosition (values , Some (deserializer)) , _ => unreachable ! () , } ;
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback . take () { None => () , Some (SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: RelPosition (_ , Some (deserializer))) => { let data = deserializer . finish (reader) ? ; SelectionConvergenceConnectionPointInElementTypeContentDeserializer :: store_rel_position (& mut values , data) ? ; } Some (_) => unreachable ! () , }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        SelectionConvergenceConnectionPointInElementTypeContentDeserializer :: store_rel_position (& mut values , data) ? ;
                        let data = SelectionConvergenceConnectionPointInElementTypeContentDeserializer :: finish_state (reader , SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: RelPosition (values , None)) ? ;
                        * self . state = SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Done__ (data) ;
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        * self . state = SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: RelPosition (values , Some (deserializer)) ;
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_connection<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ConnectionType>,
                output: DeserializerOutput<'de, super::ConnectionType>,
                fallback: &mut Option<
                    SelectionConvergenceConnectionPointInElementTypeContentDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    * self . state = match fallback . take () { None if values . is_none () => { * self . state = SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Init__ ; return Ok (ElementHandlerOutput :: from_event (event , allow_any)) ; } , None => SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Connection (values , None) , Some (SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Connection (_ , Some (deserializer))) => SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Connection (values , Some (deserializer)) , _ => unreachable ! () , } ;
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback . take () { None => () , Some (SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Connection (_ , Some (deserializer))) => { let data = deserializer . finish (reader) ? ; SelectionConvergenceConnectionPointInElementTypeContentDeserializer :: store_connection (& mut values , data) ? ; } Some (_) => unreachable ! () , }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        SelectionConvergenceConnectionPointInElementTypeContentDeserializer :: store_connection (& mut values , data) ? ;
                        let data = SelectionConvergenceConnectionPointInElementTypeContentDeserializer :: finish_state (reader , SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Connection (values , None)) ? ;
                        * self . state = SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Done__ (data) ;
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        * self . state = SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Connection (values , Some (deserializer)) ;
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_expression<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<::std::string::String>,
                output: DeserializerOutput<'de, ::std::string::String>,
                fallback: &mut Option<
                    SelectionConvergenceConnectionPointInElementTypeContentDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    * self . state = match fallback . take () { None if values . is_none () => { * self . state = SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Init__ ; return Ok (ElementHandlerOutput :: from_event (event , allow_any)) ; } , None => SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Expression (values , None) , Some (SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Expression (_ , Some (deserializer))) => SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Expression (values , Some (deserializer)) , _ => unreachable ! () , } ;
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback . take () { None => () , Some (SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Expression (_ , Some (deserializer))) => { let data = deserializer . finish (reader) ? ; SelectionConvergenceConnectionPointInElementTypeContentDeserializer :: store_expression (& mut values , data) ? ; } Some (_) => unreachable ! () , }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        SelectionConvergenceConnectionPointInElementTypeContentDeserializer :: store_expression (& mut values , data) ? ;
                        let data = SelectionConvergenceConnectionPointInElementTypeContentDeserializer :: finish_state (reader , SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Expression (values , None)) ? ;
                        * self . state = SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Done__ (data) ;
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        * self . state = SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Expression (values , Some (deserializer)) ;
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::AddDataType>,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<
                    SelectionConvergenceConnectionPointInElementTypeContentDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    * self . state = match fallback . take () { None if values . is_none () => { * self . state = SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Init__ ; return Ok (ElementHandlerOutput :: from_event (event , allow_any)) ; } , None => SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: AddData (values , None) , Some (SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: AddData (_ , Some (deserializer))) => SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: AddData (values , Some (deserializer)) , _ => unreachable ! () , } ;
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback . take () { None => () , Some (SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: AddData (_ , Some (deserializer))) => { let data = deserializer . finish (reader) ? ; SelectionConvergenceConnectionPointInElementTypeContentDeserializer :: store_add_data (& mut values , data) ? ; } Some (_) => unreachable ! () , }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        SelectionConvergenceConnectionPointInElementTypeContentDeserializer :: store_add_data (& mut values , data) ? ;
                        let data = SelectionConvergenceConnectionPointInElementTypeContentDeserializer :: finish_state (reader , SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: AddData (values , None)) ? ;
                        * self . state = SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Done__ (data) ;
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        * self . state = SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: AddData (values , Some (deserializer)) ;
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::SelectionConvergenceConnectionPointInElementTypeContent>
            for Box<SelectionConvergenceConnectionPointInElementTypeContentDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<
                'de,
                super::SelectionConvergenceConnectionPointInElementTypeContent,
            >
            where
                R: DeserializeReader,
            {
                let deserializer = Box :: new (SelectionConvergenceConnectionPointInElementTypeContentDeserializer { state : Box :: new (SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Init__) , }) ;
                let mut output = deserializer.next(reader, event)?;
                output . artifact = match output . artifact { DeserializerArtifact :: Deserializer (x) if matches ! (& * x . state , SelectionConvergenceConnectionPointInElementTypeContentDeserializerState :: Init__) => DeserializerArtifact :: None , artifact => artifact , } ;
                Ok(output)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<
                'de,
                super::SelectionConvergenceConnectionPointInElementTypeContent,
            >
            where
                R: DeserializeReader,
            {
                use SelectionConvergenceConnectionPointInElementTypeContentDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::RelPosition(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_rel_position(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Connection(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Expression(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_expression(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AddData(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (state, event @ Event::End(_)) => {
                            return Ok (DeserializerOutput { artifact : DeserializerArtifact :: Data (SelectionConvergenceConnectionPointInElementTypeContentDeserializer :: finish_state (reader , state) ?) , event : DeserializerEvent :: Continue (event) , allow_any : false , }) ;
                        }
                        (S::Init__, event) => {
                            match self.find_suitable(reader, event, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::RelPosition(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"relPosition",
                                false,
                            )?;
                            match self.handle_rel_position(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Connection(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connection",
                                false,
                            )?;
                            match self.handle_connection(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Expression(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"expression",
                                false,
                            )?;
                            match self.handle_expression(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AddData(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (s @ S::Done__(_), event) => {
                            *self.state = s;
                            break (DeserializerEvent::Continue(event), false);
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = if matches!(&*self.state, S::Done__(_)) {
                    DeserializerArtifact::Data(self.finish(reader)?)
                } else {
                    DeserializerArtifact::Deserializer(self)
                };
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                self,
                reader: &R,
            ) -> Result<super::SelectionConvergenceConnectionPointInElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                SelectionConvergenceConnectionPointInElementTypeContentDeserializer::finish_state(
                    reader,
                    *self.state,
                )
            }
        }
        #[derive(Debug)]
        pub struct EnumValuesValueElementTypeDeserializer {
            name: ::std::string::String,
            value: Option<::std::string::String>,
            state: Box<EnumValuesValueElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum EnumValuesValueElementTypeDeserializerState {
            Init__,
            Unknown__,
        }
        impl EnumValuesValueElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                let mut value: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"value")
                    ) {
                        reader.read_attrib(&mut value, b"value", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    name: name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("name".into()))
                    })?,
                    value: value,
                    state: Box::new(EnumValuesValueElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: EnumValuesValueElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                Ok(())
            }
        }
        impl<'de> Deserializer<'de, super::EnumValuesValueElementType>
            for Box<EnumValuesValueElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::EnumValuesValueElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    EnumValuesValueElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::EnumValuesValueElementType>
            where
                R: DeserializeReader,
            {
                if let Event::End(_) = &event {
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(self.finish(reader)?),
                        event: DeserializerEvent::None,
                        allow_any: false,
                    })
                } else {
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event: DeserializerEvent::Break(event),
                        allow_any: false,
                    })
                }
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::EnumValuesValueElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    EnumValuesValueElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::EnumValuesValueElementType {
                    name: self.name,
                    value: self.value,
                })
            }
        }
        #[derive(Debug)]
        pub struct ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializer {
            scaling: Option<super::PositionType>,
            state: Box<ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializerState {
            Init__,
            Scaling(Option<<super::PositionType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    scaling: None,
                    state: Box::new(
                        ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializerState::Init__,
                    ),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializerState as S;
                match state {
                    S::Scaling(Some(deserializer)) => {
                        self.store_scaling(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_scaling(&mut self, value: super::PositionType) -> Result<(), Error> {
                if self.scaling.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"scaling",
                    )))?;
                }
                self.scaling = Some(value);
                Ok(())
            }
            fn handle_scaling<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PositionType>,
                fallback: &mut Option<
                    ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.scaling.is_some() {
                        fallback . get_or_insert (ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializerState :: Scaling (None)) ;
                        * self . state = ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializerState :: Done__ ;
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        * self . state = ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializerState :: Scaling (None) ;
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_scaling(data)?;
                        * self . state = ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializerState :: Done__ ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializerState :: Scaling (Some (deserializer))) ;
                                * self . state = ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializerState :: Done__ ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializerState :: Scaling (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectContentHeaderCoordinateInfoFbdElementType>
            for Box<ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectContentHeaderCoordinateInfoFbdElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectContentHeaderCoordinateInfoFbdElementType>
            where
                R: DeserializeReader,
            {
                use ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Scaling(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_scaling(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            * self . state = ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializerState :: Scaling (None) ;
                            event
                        }
                        (S::Scaling(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"scaling",
                                false,
                            )?;
                            match self.handle_scaling(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ProjectContentHeaderCoordinateInfoFbdElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ProjectContentHeaderCoordinateInfoFbdElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ProjectContentHeaderCoordinateInfoFbdElementType {
                    scaling: self
                        .scaling
                        .ok_or_else(|| ErrorKind::MissingElement("scaling".into()))?,
                })
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesDataTypesDataTypeElementTypeDeserializer {
            name: ::std::string::String,
            base_type: Option<super::DataType>,
            initial_value: Option<super::ValueType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<ProjectTypesDataTypesDataTypeElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectTypesDataTypesDataTypeElementTypeDeserializerState {
            Init__,
            BaseType(Option<<super::DataType as WithDeserializer>::Deserializer>),
            InitialValue(Option<<super::ValueType as WithDeserializer>::Deserializer>),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl ProjectTypesDataTypesDataTypeElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    name: name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("name".into()))
                    })?,
                    base_type: None,
                    initial_value: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(
                        ProjectTypesDataTypesDataTypeElementTypeDeserializerState::Init__,
                    ),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectTypesDataTypesDataTypeElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectTypesDataTypesDataTypeElementTypeDeserializerState as S;
                match state {
                    S::BaseType(Some(deserializer)) => {
                        self.store_base_type(deserializer.finish(reader)?)?
                    }
                    S::InitialValue(Some(deserializer)) => {
                        self.store_initial_value(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_base_type(&mut self, value: super::DataType) -> Result<(), Error> {
                if self.base_type.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"baseType",
                    )))?;
                }
                self.base_type = Some(value);
                Ok(())
            }
            fn store_initial_value(&mut self, value: super::ValueType) -> Result<(), Error> {
                if self.initial_value.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"initialValue",
                    )))?;
                }
                self.initial_value = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_base_type<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::DataType>,
                fallback: &mut Option<ProjectTypesDataTypesDataTypeElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.base_type.is_some() {
                        fallback.get_or_insert(
                            ProjectTypesDataTypesDataTypeElementTypeDeserializerState::BaseType(
                                None,
                            ),
                        );
                        *self.state =
                            ProjectTypesDataTypesDataTypeElementTypeDeserializerState::InitialValue(
                                None,
                            );
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state =
                            ProjectTypesDataTypesDataTypeElementTypeDeserializerState::BaseType(
                                None,
                            );
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_base_type(data)?;
                        *self.state =
                            ProjectTypesDataTypesDataTypeElementTypeDeserializerState::InitialValue(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectTypesDataTypesDataTypeElementTypeDeserializerState :: BaseType (Some (deserializer))) ;
                                * self . state = ProjectTypesDataTypesDataTypeElementTypeDeserializerState :: InitialValue (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectTypesDataTypesDataTypeElementTypeDeserializerState :: BaseType (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_initial_value<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ValueType>,
                fallback: &mut Option<ProjectTypesDataTypesDataTypeElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectTypesDataTypesDataTypeElementTypeDeserializerState::InitialValue(
                            None,
                        ),
                    );
                    *self.state =
                        ProjectTypesDataTypesDataTypeElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_initial_value(data)?;
                        *self.state =
                            ProjectTypesDataTypesDataTypeElementTypeDeserializerState::AddData(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectTypesDataTypesDataTypeElementTypeDeserializerState :: InitialValue (Some (deserializer))) ;
                                * self . state = ProjectTypesDataTypesDataTypeElementTypeDeserializerState :: AddData (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectTypesDataTypesDataTypeElementTypeDeserializerState :: InitialValue (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<ProjectTypesDataTypesDataTypeElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectTypesDataTypesDataTypeElementTypeDeserializerState::AddData(None),
                    );
                    *self.state =
                        ProjectTypesDataTypesDataTypeElementTypeDeserializerState::Documentation(
                            None,
                        );
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        * self . state = ProjectTypesDataTypesDataTypeElementTypeDeserializerState :: Documentation (None) ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectTypesDataTypesDataTypeElementTypeDeserializerState :: AddData (Some (deserializer))) ;
                                * self . state = ProjectTypesDataTypesDataTypeElementTypeDeserializerState :: Documentation (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectTypesDataTypesDataTypeElementTypeDeserializerState :: AddData (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<ProjectTypesDataTypesDataTypeElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectTypesDataTypesDataTypeElementTypeDeserializerState::Documentation(
                            None,
                        ),
                    );
                    *self.state = ProjectTypesDataTypesDataTypeElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state =
                            ProjectTypesDataTypesDataTypeElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectTypesDataTypesDataTypeElementTypeDeserializerState :: Documentation (Some (deserializer))) ;
                                * self . state = ProjectTypesDataTypesDataTypeElementTypeDeserializerState :: Done__ ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectTypesDataTypesDataTypeElementTypeDeserializerState :: Documentation (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectTypesDataTypesDataTypeElementType>
            for Box<ProjectTypesDataTypesDataTypeElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesDataTypesDataTypeElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ProjectTypesDataTypesDataTypeElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesDataTypesDataTypeElementType>
            where
                R: DeserializeReader,
            {
                use ProjectTypesDataTypesDataTypeElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::BaseType(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_base_type(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::InitialValue(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_initial_value(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                ProjectTypesDataTypesDataTypeElementTypeDeserializerState::BaseType(
                                    None,
                                );
                            event
                        }
                        (S::BaseType(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"baseType",
                                true,
                            )?;
                            match self.handle_base_type(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::InitialValue(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"initialValue",
                                false,
                            )?;
                            match self.handle_initial_value(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ProjectTypesDataTypesDataTypeElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ProjectTypesDataTypesDataTypeElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ProjectTypesDataTypesDataTypeElementType {
                    name: self.name,
                    base_type: self
                        .base_type
                        .ok_or_else(|| ErrorKind::MissingElement("baseType".into()))?,
                    initial_value: self.initial_value,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesPousPouElementTypeDeserializer {
            name: ::std::string::String,
            pou_type: super::PouType,
            global_id: Option<::std::string::String>,
            interface: Option<super::ProjectTypesPousPouInterfaceElementType>,
            actions: Option<super::ProjectTypesPousPouActionsElementType>,
            transitions: Option<super::ProjectTypesPousPouTransitionsElementType>,
            body: Vec<super::BodyType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<ProjectTypesPousPouElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectTypesPousPouElementTypeDeserializerState {
            Init__ , Interface (Option << super :: ProjectTypesPousPouInterfaceElementType as WithDeserializer > :: Deserializer >) , Actions (Option << super :: ProjectTypesPousPouActionsElementType as WithDeserializer > :: Deserializer >) , Transitions (Option << super :: ProjectTypesPousPouTransitionsElementType as WithDeserializer > :: Deserializer >) , Body (Option << super :: BodyType as WithDeserializer > :: Deserializer >) , AddData (Option << super :: AddDataType as WithDeserializer > :: Deserializer >) , Documentation (Option << super :: FormattedTextType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl ProjectTypesPousPouElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                let mut pou_type: Option<super::PouType> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"pouType")
                    ) {
                        reader.read_attrib(&mut pou_type, b"pouType", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    name: name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("name".into()))
                    })?,
                    pou_type: pou_type.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("pouType".into()))
                    })?,
                    global_id: global_id,
                    interface: None,
                    actions: None,
                    transitions: None,
                    body: Vec::new(),
                    add_data: None,
                    documentation: None,
                    state: Box::new(ProjectTypesPousPouElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectTypesPousPouElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectTypesPousPouElementTypeDeserializerState as S;
                match state {
                    S::Interface(Some(deserializer)) => {
                        self.store_interface(deserializer.finish(reader)?)?
                    }
                    S::Actions(Some(deserializer)) => {
                        self.store_actions(deserializer.finish(reader)?)?
                    }
                    S::Transitions(Some(deserializer)) => {
                        self.store_transitions(deserializer.finish(reader)?)?
                    }
                    S::Body(Some(deserializer)) => self.store_body(deserializer.finish(reader)?)?,
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_interface(
                &mut self,
                value: super::ProjectTypesPousPouInterfaceElementType,
            ) -> Result<(), Error> {
                if self.interface.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"interface",
                    )))?;
                }
                self.interface = Some(value);
                Ok(())
            }
            fn store_actions(
                &mut self,
                value: super::ProjectTypesPousPouActionsElementType,
            ) -> Result<(), Error> {
                if self.actions.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"actions",
                    )))?;
                }
                self.actions = Some(value);
                Ok(())
            }
            fn store_transitions(
                &mut self,
                value: super::ProjectTypesPousPouTransitionsElementType,
            ) -> Result<(), Error> {
                if self.transitions.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"transitions",
                    )))?;
                }
                self.transitions = Some(value);
                Ok(())
            }
            fn store_body(&mut self, value: super::BodyType) -> Result<(), Error> {
                self.body.push(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_interface<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ProjectTypesPousPouInterfaceElementType>,
                fallback: &mut Option<ProjectTypesPousPouElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectTypesPousPouElementTypeDeserializerState::Interface(None),
                    );
                    *self.state = ProjectTypesPousPouElementTypeDeserializerState::Actions(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_interface(data)?;
                        *self.state =
                            ProjectTypesPousPouElementTypeDeserializerState::Actions(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectTypesPousPouElementTypeDeserializerState::Interface(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    ProjectTypesPousPouElementTypeDeserializerState::Actions(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ProjectTypesPousPouElementTypeDeserializerState::Interface(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_actions<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ProjectTypesPousPouActionsElementType>,
                fallback: &mut Option<ProjectTypesPousPouElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectTypesPousPouElementTypeDeserializerState::Actions(None),
                    );
                    *self.state =
                        ProjectTypesPousPouElementTypeDeserializerState::Transitions(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_actions(data)?;
                        *self.state =
                            ProjectTypesPousPouElementTypeDeserializerState::Transitions(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectTypesPousPouElementTypeDeserializerState::Actions(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    ProjectTypesPousPouElementTypeDeserializerState::Transitions(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ProjectTypesPousPouElementTypeDeserializerState::Actions(Some(
                                        deserializer,
                                    ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_transitions<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ProjectTypesPousPouTransitionsElementType>,
                fallback: &mut Option<ProjectTypesPousPouElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectTypesPousPouElementTypeDeserializerState::Transitions(None),
                    );
                    *self.state = ProjectTypesPousPouElementTypeDeserializerState::Body(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_transitions(data)?;
                        *self.state = ProjectTypesPousPouElementTypeDeserializerState::Body(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectTypesPousPouElementTypeDeserializerState::Transitions(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    ProjectTypesPousPouElementTypeDeserializerState::Body(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ProjectTypesPousPouElementTypeDeserializerState::Transitions(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_body<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::BodyType>,
                fallback: &mut Option<ProjectTypesPousPouElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback
                        .get_or_insert(ProjectTypesPousPouElementTypeDeserializerState::Body(None));
                    *self.state = ProjectTypesPousPouElementTypeDeserializerState::AddData(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_body(data)?;
                        *self.state = ProjectTypesPousPouElementTypeDeserializerState::Body(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectTypesPousPouElementTypeDeserializerState::Body(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    ProjectTypesPousPouElementTypeDeserializerState::Body(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = ProjectTypesPousPouElementTypeDeserializerState::Body(
                                    Some(deserializer),
                                );
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<ProjectTypesPousPouElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectTypesPousPouElementTypeDeserializerState::AddData(None),
                    );
                    *self.state =
                        ProjectTypesPousPouElementTypeDeserializerState::Documentation(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        *self.state =
                            ProjectTypesPousPouElementTypeDeserializerState::Documentation(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectTypesPousPouElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    )),
                                );
                                *self.state =
                                    ProjectTypesPousPouElementTypeDeserializerState::Documentation(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ProjectTypesPousPouElementTypeDeserializerState::AddData(Some(
                                        deserializer,
                                    ));
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<ProjectTypesPousPouElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectTypesPousPouElementTypeDeserializerState::Documentation(None),
                    );
                    *self.state = ProjectTypesPousPouElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state = ProjectTypesPousPouElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectTypesPousPouElementTypeDeserializerState::Documentation(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    ProjectTypesPousPouElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ProjectTypesPousPouElementTypeDeserializerState::Documentation(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectTypesPousPouElementType>
            for Box<ProjectTypesPousPouElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesPousPouElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ProjectTypesPousPouElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesPousPouElementType>
            where
                R: DeserializeReader,
            {
                use ProjectTypesPousPouElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Interface(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_interface(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Actions(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_actions(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Transitions(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_transitions(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Body(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_body(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                ProjectTypesPousPouElementTypeDeserializerState::Interface(None);
                            event
                        }
                        (S::Interface(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"interface",
                                true,
                            )?;
                            match self.handle_interface(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Actions(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"actions",
                                true,
                            )?;
                            match self.handle_actions(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Transitions(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"transitions",
                                true,
                            )?;
                            match self.handle_transitions(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Body(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"body",
                                true,
                            )?;
                            match self.handle_body(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ProjectTypesPousPouElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ProjectTypesPousPouElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ProjectTypesPousPouElementType {
                    name: self.name,
                    pou_type: self.pou_type,
                    global_id: self.global_id,
                    interface: self.interface,
                    actions: self.actions,
                    transitions: self.transitions,
                    body: self.body,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct ProjectInstancesConfigurationsConfigurationElementTypeDeserializer {
            name: ::std::string::String,
            global_id: Option<::std::string::String>,
            resource: Vec<super::ProjectInstancesConfigurationsConfigurationResourceElementType>,
            global_vars: Vec<super::VarListType>,
            access_vars: Option<super::VarListAccessType>,
            config_vars: Option<super::VarListConfigType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState {
            Init__ , Resource (Option << super :: ProjectInstancesConfigurationsConfigurationResourceElementType as WithDeserializer > :: Deserializer >) , GlobalVars (Option << super :: VarListType as WithDeserializer > :: Deserializer >) , AccessVars (Option << super :: VarListAccessType as WithDeserializer > :: Deserializer >) , ConfigVars (Option << super :: VarListConfigType as WithDeserializer > :: Deserializer >) , AddData (Option << super :: AddDataType as WithDeserializer > :: Deserializer >) , Documentation (Option << super :: FormattedTextType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl ProjectInstancesConfigurationsConfigurationElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok (Box :: new (Self { name : name . ok_or_else (|| reader . map_error (ErrorKind :: MissingAttribute ("name" . into ()))) ? , global_id : global_id , resource : Vec :: new () , global_vars : Vec :: new () , access_vars : None , config_vars : None , add_data : None , documentation : None , state : Box :: new (ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: Init__) , }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState as S;
                match state {
                    S::Resource(Some(deserializer)) => {
                        self.store_resource(deserializer.finish(reader)?)?
                    }
                    S::GlobalVars(Some(deserializer)) => {
                        self.store_global_vars(deserializer.finish(reader)?)?
                    }
                    S::AccessVars(Some(deserializer)) => {
                        self.store_access_vars(deserializer.finish(reader)?)?
                    }
                    S::ConfigVars(Some(deserializer)) => {
                        self.store_config_vars(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_resource(
                &mut self,
                value: super::ProjectInstancesConfigurationsConfigurationResourceElementType,
            ) -> Result<(), Error> {
                self.resource.push(value);
                Ok(())
            }
            fn store_global_vars(&mut self, value: super::VarListType) -> Result<(), Error> {
                self.global_vars.push(value);
                Ok(())
            }
            fn store_access_vars(&mut self, value: super::VarListAccessType) -> Result<(), Error> {
                if self.access_vars.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"accessVars",
                    )))?;
                }
                self.access_vars = Some(value);
                Ok(())
            }
            fn store_config_vars(&mut self, value: super::VarListConfigType) -> Result<(), Error> {
                if self.config_vars.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"configVars",
                    )))?;
                }
                self.config_vars = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_resource<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<
                    'de,
                    super::ProjectInstancesConfigurationsConfigurationResourceElementType,
                >,
                fallback: &mut Option<
                    ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: Resource (None)) ;
                    * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: GlobalVars (None) ;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_resource(data)?;
                        * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: Resource (None) ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: Resource (Some (deserializer))) ;
                                * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: Resource (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: Resource (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_global_vars<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::VarListType>,
                fallback: &mut Option<
                    ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: GlobalVars (None)) ;
                    * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: AccessVars (None) ;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_global_vars(data)?;
                        * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: GlobalVars (None) ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: GlobalVars (Some (deserializer))) ;
                                * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: GlobalVars (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: GlobalVars (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_access_vars<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::VarListAccessType>,
                fallback: &mut Option<
                    ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: AccessVars (None)) ;
                    * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: ConfigVars (None) ;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_access_vars(data)?;
                        * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: ConfigVars (None) ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: AccessVars (Some (deserializer))) ;
                                * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: ConfigVars (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: AccessVars (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_config_vars<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::VarListConfigType>,
                fallback: &mut Option<
                    ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: ConfigVars (None)) ;
                    * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: AddData (None) ;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_config_vars(data)?;
                        * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: AddData (None) ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: ConfigVars (Some (deserializer))) ;
                                * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: AddData (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: ConfigVars (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<
                    ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: AddData (None)) ;
                    * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: Documentation (None) ;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: Documentation (None) ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: AddData (Some (deserializer))) ;
                                * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: Documentation (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: AddData (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<
                    ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: Documentation (None)) ;
                    * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: Done__ ;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: Done__ ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: Documentation (Some (deserializer))) ;
                                * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: Done__ ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: Documentation (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectInstancesConfigurationsConfigurationElementType>
            for Box<ProjectInstancesConfigurationsConfigurationElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<
                'de,
                super::ProjectInstancesConfigurationsConfigurationElementType,
            >
            where
                R: DeserializeReader,
            {
                reader . init_deserializer_from_start_event (event , ProjectInstancesConfigurationsConfigurationElementTypeDeserializer :: from_bytes_start)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<
                'de,
                super::ProjectInstancesConfigurationsConfigurationElementType,
            >
            where
                R: DeserializeReader,
            {
                use ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Resource(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_resource(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::GlobalVars(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_global_vars(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AccessVars(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_access_vars(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConfigVars(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_config_vars(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            * self . state = ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: Resource (None) ;
                            event
                        }
                        (S::Resource(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"resource",
                                true,
                            )?;
                            match self.handle_resource(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::GlobalVars(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"globalVars",
                                true,
                            )?;
                            match self.handle_global_vars(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AccessVars(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"accessVars",
                                true,
                            )?;
                            match self.handle_access_vars(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConfigVars(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"configVars",
                                true,
                            )?;
                            match self.handle_config_vars(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ProjectInstancesConfigurationsConfigurationElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace (& mut * self . state , ProjectInstancesConfigurationsConfigurationElementTypeDeserializerState :: Unknown__) ;
                self.finish_state(reader, state)?;
                Ok(
                    super::ProjectInstancesConfigurationsConfigurationElementType {
                        name: self.name,
                        global_id: self.global_id,
                        resource: self.resource,
                        global_vars: self.global_vars,
                        access_vars: self.access_vars,
                        config_vars: self.config_vars,
                        add_data: self.add_data,
                        documentation: self.documentation,
                    },
                )
            }
        }
        #[derive(Debug)]
        pub struct ActionBlockActionReferenceElementTypeDeserializer {
            name: ::std::string::String,
            state: Box<ActionBlockActionReferenceElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ActionBlockActionReferenceElementTypeDeserializerState {
            Init__,
            Unknown__,
        }
        impl ActionBlockActionReferenceElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    name: name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("name".into()))
                    })?,
                    state: Box::new(ActionBlockActionReferenceElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ActionBlockActionReferenceElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                Ok(())
            }
        }
        impl<'de> Deserializer<'de, super::ActionBlockActionReferenceElementType>
            for Box<ActionBlockActionReferenceElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ActionBlockActionReferenceElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ActionBlockActionReferenceElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ActionBlockActionReferenceElementType>
            where
                R: DeserializeReader,
            {
                if let Event::End(_) = &event {
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(self.finish(reader)?),
                        event: DeserializerEvent::None,
                        allow_any: false,
                    })
                } else {
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event: DeserializerEvent::Break(event),
                        allow_any: false,
                    })
                }
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ActionBlockActionReferenceElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ActionBlockActionReferenceElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ActionBlockActionReferenceElementType { name: self.name })
            }
        }
        #[derive(Debug)]
        pub struct BlockInputVariablesVariableElementTypeDeserializer {
            formal_parameter: ::std::string::String,
            negated: ::core::primitive::bool,
            edge: super::EdgeModifierType,
            storage: super::StorageModifierType,
            hidden: ::core::primitive::bool,
            connection_point_in: Option<super::ConnectionPointInType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<BlockInputVariablesVariableElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum BlockInputVariablesVariableElementTypeDeserializerState {
            Init__,
            ConnectionPointIn(
                Option<<super::ConnectionPointInType as WithDeserializer>::Deserializer>,
            ),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl BlockInputVariablesVariableElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut formal_parameter: Option<::std::string::String> = None;
                let mut negated: Option<::core::primitive::bool> = None;
                let mut edge: Option<super::EdgeModifierType> = None;
                let mut storage: Option<super::StorageModifierType> = None;
                let mut hidden: Option<::core::primitive::bool> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"formalParameter")
                    ) {
                        reader.read_attrib(
                            &mut formal_parameter,
                            b"formalParameter",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"negated")
                    ) {
                        reader.read_attrib(&mut negated, b"negated", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"edge")
                    ) {
                        reader.read_attrib(&mut edge, b"edge", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"storage")
                    ) {
                        reader.read_attrib(&mut storage, b"storage", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"hidden")
                    ) {
                        reader.read_attrib(&mut hidden, b"hidden", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    formal_parameter: formal_parameter.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("formalParameter".into()))
                    })?,
                    negated: negated.unwrap_or_else(
                        super::BlockInputVariablesVariableElementType::default_negated,
                    ),
                    edge: edge.unwrap_or_else(
                        super::BlockInputVariablesVariableElementType::default_edge,
                    ),
                    storage: storage.unwrap_or_else(
                        super::BlockInputVariablesVariableElementType::default_storage,
                    ),
                    hidden: hidden.unwrap_or_else(
                        super::BlockInputVariablesVariableElementType::default_hidden,
                    ),
                    connection_point_in: None,
                    documentation: None,
                    state: Box::new(
                        BlockInputVariablesVariableElementTypeDeserializerState::Init__,
                    ),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: BlockInputVariablesVariableElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use BlockInputVariablesVariableElementTypeDeserializerState as S;
                match state {
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                if self.connection_point_in.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointIn",
                    )))?;
                }
                self.connection_point_in = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<BlockInputVariablesVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.connection_point_in.is_some() {
                        fallback . get_or_insert (BlockInputVariablesVariableElementTypeDeserializerState :: ConnectionPointIn (None)) ;
                        *self.state =
                            BlockInputVariablesVariableElementTypeDeserializerState::Documentation(
                                None,
                            );
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        * self . state = BlockInputVariablesVariableElementTypeDeserializerState :: ConnectionPointIn (None) ;
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        *self.state =
                            BlockInputVariablesVariableElementTypeDeserializerState::Documentation(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (BlockInputVariablesVariableElementTypeDeserializerState :: ConnectionPointIn (Some (deserializer))) ;
                                * self . state = BlockInputVariablesVariableElementTypeDeserializerState :: Documentation (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = BlockInputVariablesVariableElementTypeDeserializerState :: ConnectionPointIn (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<BlockInputVariablesVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        BlockInputVariablesVariableElementTypeDeserializerState::Documentation(
                            None,
                        ),
                    );
                    *self.state = BlockInputVariablesVariableElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state =
                            BlockInputVariablesVariableElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (BlockInputVariablesVariableElementTypeDeserializerState :: Documentation (Some (deserializer))) ;
                                *self.state =
                                    BlockInputVariablesVariableElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = BlockInputVariablesVariableElementTypeDeserializerState :: Documentation (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::BlockInputVariablesVariableElementType>
            for Box<BlockInputVariablesVariableElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BlockInputVariablesVariableElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    BlockInputVariablesVariableElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BlockInputVariablesVariableElementType>
            where
                R: DeserializeReader,
            {
                use BlockInputVariablesVariableElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            * self . state = BlockInputVariablesVariableElementTypeDeserializerState :: ConnectionPointIn (None) ;
                            event
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::BlockInputVariablesVariableElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    BlockInputVariablesVariableElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::BlockInputVariablesVariableElementType {
                    formal_parameter: self.formal_parameter,
                    negated: self.negated,
                    edge: self.edge,
                    storage: self.storage,
                    hidden: self.hidden,
                    connection_point_in: self
                        .connection_point_in
                        .ok_or_else(|| ErrorKind::MissingElement("connectionPointIn".into()))?,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct BlockInOutVariablesVariableElementTypeDeserializer {
            formal_parameter: ::std::string::String,
            negated: ::core::primitive::bool,
            edge: super::EdgeModifierType,
            storage: super::StorageModifierType,
            hidden: ::core::primitive::bool,
            connection_point_in: Option<super::ConnectionPointInType>,
            connection_point_out: Option<super::ConnectionPointOutType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<BlockInOutVariablesVariableElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum BlockInOutVariablesVariableElementTypeDeserializerState {
            Init__,
            ConnectionPointIn(
                Option<<super::ConnectionPointInType as WithDeserializer>::Deserializer>,
            ),
            ConnectionPointOut(
                Option<<super::ConnectionPointOutType as WithDeserializer>::Deserializer>,
            ),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl BlockInOutVariablesVariableElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut formal_parameter: Option<::std::string::String> = None;
                let mut negated: Option<::core::primitive::bool> = None;
                let mut edge: Option<super::EdgeModifierType> = None;
                let mut storage: Option<super::StorageModifierType> = None;
                let mut hidden: Option<::core::primitive::bool> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"formalParameter")
                    ) {
                        reader.read_attrib(
                            &mut formal_parameter,
                            b"formalParameter",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"negated")
                    ) {
                        reader.read_attrib(&mut negated, b"negated", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"edge")
                    ) {
                        reader.read_attrib(&mut edge, b"edge", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"storage")
                    ) {
                        reader.read_attrib(&mut storage, b"storage", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"hidden")
                    ) {
                        reader.read_attrib(&mut hidden, b"hidden", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    formal_parameter: formal_parameter.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("formalParameter".into()))
                    })?,
                    negated: negated.unwrap_or_else(
                        super::BlockInOutVariablesVariableElementType::default_negated,
                    ),
                    edge: edge.unwrap_or_else(
                        super::BlockInOutVariablesVariableElementType::default_edge,
                    ),
                    storage: storage.unwrap_or_else(
                        super::BlockInOutVariablesVariableElementType::default_storage,
                    ),
                    hidden: hidden.unwrap_or_else(
                        super::BlockInOutVariablesVariableElementType::default_hidden,
                    ),
                    connection_point_in: None,
                    connection_point_out: None,
                    documentation: None,
                    state: Box::new(
                        BlockInOutVariablesVariableElementTypeDeserializerState::Init__,
                    ),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: BlockInOutVariablesVariableElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use BlockInOutVariablesVariableElementTypeDeserializerState as S;
                match state {
                    S::ConnectionPointIn(Some(deserializer)) => {
                        self.store_connection_point_in(deserializer.finish(reader)?)?
                    }
                    S::ConnectionPointOut(Some(deserializer)) => {
                        self.store_connection_point_out(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_connection_point_in(
                &mut self,
                value: super::ConnectionPointInType,
            ) -> Result<(), Error> {
                if self.connection_point_in.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointIn",
                    )))?;
                }
                self.connection_point_in = Some(value);
                Ok(())
            }
            fn store_connection_point_out(
                &mut self,
                value: super::ConnectionPointOutType,
            ) -> Result<(), Error> {
                if self.connection_point_out.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointOut",
                    )))?;
                }
                self.connection_point_out = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_connection_point_in<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointInType>,
                fallback: &mut Option<BlockInOutVariablesVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        BlockInOutVariablesVariableElementTypeDeserializerState::ConnectionPointIn(
                            None,
                        ),
                    );
                    *self.state =
                        BlockInOutVariablesVariableElementTypeDeserializerState::ConnectionPointOut(
                            None,
                        );
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_in(data)?;
                        * self . state = BlockInOutVariablesVariableElementTypeDeserializerState :: ConnectionPointOut (None) ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (BlockInOutVariablesVariableElementTypeDeserializerState :: ConnectionPointIn (Some (deserializer))) ;
                                * self . state = BlockInOutVariablesVariableElementTypeDeserializerState :: ConnectionPointOut (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = BlockInOutVariablesVariableElementTypeDeserializerState :: ConnectionPointIn (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_connection_point_out<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointOutType>,
                fallback: &mut Option<BlockInOutVariablesVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        BlockInOutVariablesVariableElementTypeDeserializerState::ConnectionPointOut(
                            None,
                        ),
                    );
                    *self.state =
                        BlockInOutVariablesVariableElementTypeDeserializerState::Documentation(
                            None,
                        );
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_out(data)?;
                        *self.state =
                            BlockInOutVariablesVariableElementTypeDeserializerState::Documentation(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (BlockInOutVariablesVariableElementTypeDeserializerState :: ConnectionPointOut (Some (deserializer))) ;
                                * self . state = BlockInOutVariablesVariableElementTypeDeserializerState :: Documentation (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = BlockInOutVariablesVariableElementTypeDeserializerState :: ConnectionPointOut (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<BlockInOutVariablesVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        BlockInOutVariablesVariableElementTypeDeserializerState::Documentation(
                            None,
                        ),
                    );
                    *self.state = BlockInOutVariablesVariableElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state =
                            BlockInOutVariablesVariableElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (BlockInOutVariablesVariableElementTypeDeserializerState :: Documentation (Some (deserializer))) ;
                                *self.state =
                                    BlockInOutVariablesVariableElementTypeDeserializerState::Done__;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = BlockInOutVariablesVariableElementTypeDeserializerState :: Documentation (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::BlockInOutVariablesVariableElementType>
            for Box<BlockInOutVariablesVariableElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BlockInOutVariablesVariableElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    BlockInOutVariablesVariableElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BlockInOutVariablesVariableElementType>
            where
                R: DeserializeReader,
            {
                use BlockInOutVariablesVariableElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::ConnectionPointIn(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::ConnectionPointOut(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            * self . state = BlockInOutVariablesVariableElementTypeDeserializerState :: ConnectionPointIn (None) ;
                            event
                        }
                        (
                            S::ConnectionPointIn(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointIn",
                                true,
                            )?;
                            match self.handle_connection_point_in(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (
                            S::ConnectionPointOut(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointOut",
                                false,
                            )?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::BlockInOutVariablesVariableElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    BlockInOutVariablesVariableElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::BlockInOutVariablesVariableElementType {
                    formal_parameter: self.formal_parameter,
                    negated: self.negated,
                    edge: self.edge,
                    storage: self.storage,
                    hidden: self.hidden,
                    connection_point_in: self.connection_point_in,
                    connection_point_out: self.connection_point_out,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct BlockOutputVariablesVariableElementTypeDeserializer {
            formal_parameter: ::std::string::String,
            negated: ::core::primitive::bool,
            edge: super::EdgeModifierType,
            storage: super::StorageModifierType,
            hidden: ::core::primitive::bool,
            connection_point_out: Option<super::ConnectionPointOutType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<BlockOutputVariablesVariableElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum BlockOutputVariablesVariableElementTypeDeserializerState {
            Init__,
            ConnectionPointOut(
                Option<<super::ConnectionPointOutType as WithDeserializer>::Deserializer>,
            ),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl BlockOutputVariablesVariableElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut formal_parameter: Option<::std::string::String> = None;
                let mut negated: Option<::core::primitive::bool> = None;
                let mut edge: Option<super::EdgeModifierType> = None;
                let mut storage: Option<super::StorageModifierType> = None;
                let mut hidden: Option<::core::primitive::bool> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"formalParameter")
                    ) {
                        reader.read_attrib(
                            &mut formal_parameter,
                            b"formalParameter",
                            &attrib.value,
                        )?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"negated")
                    ) {
                        reader.read_attrib(&mut negated, b"negated", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"edge")
                    ) {
                        reader.read_attrib(&mut edge, b"edge", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"storage")
                    ) {
                        reader.read_attrib(&mut storage, b"storage", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"hidden")
                    ) {
                        reader.read_attrib(&mut hidden, b"hidden", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    formal_parameter: formal_parameter.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("formalParameter".into()))
                    })?,
                    negated: negated.unwrap_or_else(
                        super::BlockOutputVariablesVariableElementType::default_negated,
                    ),
                    edge: edge.unwrap_or_else(
                        super::BlockOutputVariablesVariableElementType::default_edge,
                    ),
                    storage: storage.unwrap_or_else(
                        super::BlockOutputVariablesVariableElementType::default_storage,
                    ),
                    hidden: hidden.unwrap_or_else(
                        super::BlockOutputVariablesVariableElementType::default_hidden,
                    ),
                    connection_point_out: None,
                    documentation: None,
                    state: Box::new(
                        BlockOutputVariablesVariableElementTypeDeserializerState::Init__,
                    ),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: BlockOutputVariablesVariableElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use BlockOutputVariablesVariableElementTypeDeserializerState as S;
                match state {
                    S::ConnectionPointOut(Some(deserializer)) => {
                        self.store_connection_point_out(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_connection_point_out(
                &mut self,
                value: super::ConnectionPointOutType,
            ) -> Result<(), Error> {
                if self.connection_point_out.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"connectionPointOut",
                    )))?;
                }
                self.connection_point_out = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_connection_point_out<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ConnectionPointOutType>,
                fallback: &mut Option<BlockOutputVariablesVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (BlockOutputVariablesVariableElementTypeDeserializerState :: ConnectionPointOut (None)) ;
                    *self.state =
                        BlockOutputVariablesVariableElementTypeDeserializerState::Documentation(
                            None,
                        );
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_connection_point_out(data)?;
                        *self.state =
                            BlockOutputVariablesVariableElementTypeDeserializerState::Documentation(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (BlockOutputVariablesVariableElementTypeDeserializerState :: ConnectionPointOut (Some (deserializer))) ;
                                * self . state = BlockOutputVariablesVariableElementTypeDeserializerState :: Documentation (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = BlockOutputVariablesVariableElementTypeDeserializerState :: ConnectionPointOut (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<BlockOutputVariablesVariableElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        BlockOutputVariablesVariableElementTypeDeserializerState::Documentation(
                            None,
                        ),
                    );
                    *self.state = BlockOutputVariablesVariableElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state =
                            BlockOutputVariablesVariableElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (BlockOutputVariablesVariableElementTypeDeserializerState :: Documentation (Some (deserializer))) ;
                                * self . state = BlockOutputVariablesVariableElementTypeDeserializerState :: Done__ ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = BlockOutputVariablesVariableElementTypeDeserializerState :: Documentation (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::BlockOutputVariablesVariableElementType>
            for Box<BlockOutputVariablesVariableElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BlockOutputVariablesVariableElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    BlockOutputVariablesVariableElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::BlockOutputVariablesVariableElementType>
            where
                R: DeserializeReader,
            {
                use BlockOutputVariablesVariableElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::ConnectionPointOut(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            * self . state = BlockOutputVariablesVariableElementTypeDeserializerState :: ConnectionPointOut (None) ;
                            event
                        }
                        (
                            S::ConnectionPointOut(None),
                            event @ (Event::Start(_) | Event::Empty(_)),
                        ) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"connectionPointOut",
                                false,
                            )?;
                            match self.handle_connection_point_out(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::BlockOutputVariablesVariableElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    BlockOutputVariablesVariableElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::BlockOutputVariablesVariableElementType {
                    formal_parameter: self.formal_parameter,
                    negated: self.negated,
                    edge: self.edge,
                    storage: self.storage,
                    hidden: self.hidden,
                    connection_point_out: self.connection_point_out,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct TransitionConditionInlineElementTypeDeserializer {
            worksheet_name: Option<::std::string::String>,
            global_id: Option<::std::string::String>,
            name: ::std::string::String,
            content: Vec<super::TransitionConditionInlineElementTypeContent>,
            state: Box<TransitionConditionInlineElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum TransitionConditionInlineElementTypeDeserializerState {
            Init__ , Next__ , Content__ (< super :: TransitionConditionInlineElementTypeContent as WithDeserializer > :: Deserializer) , Unknown__ , }
        impl TransitionConditionInlineElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut worksheet_name: Option<::std::string::String> = None;
                let mut global_id: Option<::std::string::String> = None;
                let mut name: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"WorksheetName")
                    ) {
                        reader.read_attrib(&mut worksheet_name, b"WorksheetName", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    worksheet_name: worksheet_name,
                    global_id: global_id,
                    name: name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("name".into()))
                    })?,
                    content: Vec::new(),
                    state: Box::new(TransitionConditionInlineElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: TransitionConditionInlineElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                if let TransitionConditionInlineElementTypeDeserializerState::Content__(
                    deserializer,
                ) = state
                {
                    self.store_content(deserializer.finish(reader)?)?;
                }
                Ok(())
            }
            fn store_content(
                &mut self,
                value: super::TransitionConditionInlineElementTypeContent,
            ) -> Result<(), Error> {
                self.content.push(value);
                Ok(())
            }
            fn handle_content<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::TransitionConditionInlineElementTypeContent>,
                fallback: &mut Option<TransitionConditionInlineElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = fallback
                        .take()
                        .unwrap_or(TransitionConditionInlineElementTypeDeserializerState::Next__);
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_content(data)?;
                        *self.state = TransitionConditionInlineElementTypeDeserializerState::Next__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let can_have_more = self.content.len().saturating_add(1) < 3usize;
                        let ret = if can_have_more {
                            ElementHandlerOutput::from_event(event, allow_any)
                        } else {
                            ElementHandlerOutput::from_event_end(event, allow_any)
                        };
                        match (can_have_more, &ret) {
                            (true, ElementHandlerOutput::Continue { .. }) => {
                                fallback . get_or_insert (TransitionConditionInlineElementTypeDeserializerState :: Content__ (deserializer)) ;
                                *self.state =
                                    TransitionConditionInlineElementTypeDeserializerState::Next__;
                            }
                            (false, _) | (_, ElementHandlerOutput::Break { .. }) => {
                                * self . state = TransitionConditionInlineElementTypeDeserializerState :: Content__ (deserializer) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::TransitionConditionInlineElementType>
            for Box<TransitionConditionInlineElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::TransitionConditionInlineElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    TransitionConditionInlineElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::TransitionConditionInlineElementType>
            where
                R: DeserializeReader,
            {
                use TransitionConditionInlineElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Content__(deserializer), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (_, Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (state @ (S::Init__ | S::Next__), event) => {
                            fallback.get_or_insert(state);
                            let output = < super :: TransitionConditionInlineElementTypeContent as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = DeserializerArtifact::Deserializer(self);
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::TransitionConditionInlineElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    TransitionConditionInlineElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::TransitionConditionInlineElementType {
                    worksheet_name: self.worksheet_name,
                    global_id: self.global_id,
                    name: self.name,
                    content: self.content,
                })
            }
        }
        #[derive(Debug)]
        pub struct TransitionConditionInlineElementTypeContentDeserializer {
            state: Box<TransitionConditionInlineElementTypeContentDeserializerState>,
        }
        #[derive(Debug)]
        pub enum TransitionConditionInlineElementTypeContentDeserializerState {
            Init__,
            Il(
                Option<super::FormattedTextType>,
                Option<<super::FormattedTextType as WithDeserializer>::Deserializer>,
            ),
            St(
                Option<super::FormattedTextType>,
                Option<<super::FormattedTextType as WithDeserializer>::Deserializer>,
            ),
            Fbd(
                Option<super::BodyFbdElementType>,
                Option<<super::BodyFbdElementType as WithDeserializer>::Deserializer>,
            ),
            Ld(
                Option<super::BodyLdElementType>,
                Option<<super::BodyLdElementType as WithDeserializer>::Deserializer>,
            ),
            Sfc(
                Option<super::BodySfcElementType>,
                Option<<super::BodySfcElementType as WithDeserializer>::Deserializer>,
            ),
            AddData(
                Option<super::AddDataType>,
                Option<<super::AddDataType as WithDeserializer>::Deserializer>,
            ),
            Documentation(
                Option<super::FormattedTextType>,
                Option<<super::FormattedTextType as WithDeserializer>::Deserializer>,
            ),
            Done__(super::TransitionConditionInlineElementTypeContent),
            Unknown__,
        }
        impl TransitionConditionInlineElementTypeContentDeserializer {
            fn find_suitable<'de, R>(
                &mut self,
                reader: &R,
                event: Event<'de>,
                fallback: &mut Option<TransitionConditionInlineElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                if let Event::Start(x) | Event::Empty(x) = &event {
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"IL")
                    ) {
                        let output =
                            <super::FormattedTextType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_il(reader, Default::default(), output, &mut *fallback);
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"ST")
                    ) {
                        let output =
                            <super::FormattedTextType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_st(reader, Default::default(), output, &mut *fallback);
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"FBD")
                    ) {
                        let output =
                            <super::BodyFbdElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_fbd(reader, Default::default(), output, &mut *fallback);
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"LD")
                    ) {
                        let output =
                            <super::BodyLdElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_ld(reader, Default::default(), output, &mut *fallback);
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"SFC")
                    ) {
                        let output =
                            <super::BodySfcElementType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_sfc(reader, Default::default(), output, &mut *fallback);
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"addData")
                    ) {
                        let output = <super::AddDataType as WithDeserializer>::Deserializer::init(
                            reader, event,
                        )?;
                        return self.handle_add_data(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"documentation")
                    ) {
                        let output =
                            <super::FormattedTextType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_documentation(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                }
                *self.state = fallback.take().unwrap_or(
                    TransitionConditionInlineElementTypeContentDeserializerState::Init__,
                );
                Ok(ElementHandlerOutput::return_to_parent(event, false))
            }
            fn finish_state<R>(
                reader: &R,
                state: TransitionConditionInlineElementTypeContentDeserializerState,
            ) -> Result<super::TransitionConditionInlineElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                use TransitionConditionInlineElementTypeContentDeserializerState as S;
                match state {
                    S::Init__ => Err(ErrorKind::MissingContent.into()),
                    S::Il(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            TransitionConditionInlineElementTypeContentDeserializer::store_il(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::TransitionConditionInlineElementTypeContent::Il(
                            values.ok_or_else(|| ErrorKind::MissingElement("IL".into()))?,
                        ))
                    }
                    S::St(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            TransitionConditionInlineElementTypeContentDeserializer::store_st(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::TransitionConditionInlineElementTypeContent::St(
                            values.ok_or_else(|| ErrorKind::MissingElement("ST".into()))?,
                        ))
                    }
                    S::Fbd(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            TransitionConditionInlineElementTypeContentDeserializer::store_fbd(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::TransitionConditionInlineElementTypeContent::Fbd(
                            values.ok_or_else(|| ErrorKind::MissingElement("FBD".into()))?,
                        ))
                    }
                    S::Ld(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            TransitionConditionInlineElementTypeContentDeserializer::store_ld(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::TransitionConditionInlineElementTypeContent::Ld(
                            values.ok_or_else(|| ErrorKind::MissingElement("LD".into()))?,
                        ))
                    }
                    S::Sfc(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            TransitionConditionInlineElementTypeContentDeserializer::store_sfc(
                                &mut values,
                                value,
                            )?;
                        }
                        Ok(super::TransitionConditionInlineElementTypeContent::Sfc(
                            values.ok_or_else(|| ErrorKind::MissingElement("SFC".into()))?,
                        ))
                    }
                    S::AddData(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            TransitionConditionInlineElementTypeContentDeserializer :: store_add_data (& mut values , value) ? ;
                        }
                        Ok(super::TransitionConditionInlineElementTypeContent::AddData(
                            values.ok_or_else(|| ErrorKind::MissingElement("addData".into()))?,
                        ))
                    }
                    S::Documentation(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            TransitionConditionInlineElementTypeContentDeserializer :: store_documentation (& mut values , value) ? ;
                        }
                        Ok(
                            super::TransitionConditionInlineElementTypeContent::Documentation(
                                values.ok_or_else(|| {
                                    ErrorKind::MissingElement("documentation".into())
                                })?,
                            ),
                        )
                    }
                    S::Done__(data) => Ok(data),
                    S::Unknown__ => unreachable!(),
                }
            }
            fn store_il(
                values: &mut Option<super::FormattedTextType>,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"IL")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_st(
                values: &mut Option<super::FormattedTextType>,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"ST")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_fbd(
                values: &mut Option<super::BodyFbdElementType>,
                value: super::BodyFbdElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"FBD")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_ld(
                values: &mut Option<super::BodyLdElementType>,
                value: super::BodyLdElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"LD")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_sfc(
                values: &mut Option<super::BodySfcElementType>,
                value: super::BodySfcElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"SFC")))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_add_data(
                values: &mut Option<super::AddDataType>,
                value: super::AddDataType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_documentation(
                values: &mut Option<super::FormattedTextType>,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn handle_il<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::FormattedTextType>,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<TransitionConditionInlineElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            * self . state = TransitionConditionInlineElementTypeContentDeserializerState :: Init__ ;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => TransitionConditionInlineElementTypeContentDeserializerState::Il(
                            values, None,
                        ),
                        Some(TransitionConditionInlineElementTypeContentDeserializerState::Il(
                            _,
                            Some(deserializer),
                        )) => TransitionConditionInlineElementTypeContentDeserializerState::Il(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(TransitionConditionInlineElementTypeContentDeserializerState::Il(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        TransitionConditionInlineElementTypeContentDeserializer::store_il(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        TransitionConditionInlineElementTypeContentDeserializer::store_il(
                            &mut values,
                            data,
                        )?;
                        let data =
                            TransitionConditionInlineElementTypeContentDeserializer::finish_state(
                                reader,
                                TransitionConditionInlineElementTypeContentDeserializerState::Il(
                                    values, None,
                                ),
                            )?;
                        *self.state =
                            TransitionConditionInlineElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            TransitionConditionInlineElementTypeContentDeserializerState::Il(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_st<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::FormattedTextType>,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<TransitionConditionInlineElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            * self . state = TransitionConditionInlineElementTypeContentDeserializerState :: Init__ ;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => TransitionConditionInlineElementTypeContentDeserializerState::St(
                            values, None,
                        ),
                        Some(TransitionConditionInlineElementTypeContentDeserializerState::St(
                            _,
                            Some(deserializer),
                        )) => TransitionConditionInlineElementTypeContentDeserializerState::St(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(TransitionConditionInlineElementTypeContentDeserializerState::St(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        TransitionConditionInlineElementTypeContentDeserializer::store_st(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        TransitionConditionInlineElementTypeContentDeserializer::store_st(
                            &mut values,
                            data,
                        )?;
                        let data =
                            TransitionConditionInlineElementTypeContentDeserializer::finish_state(
                                reader,
                                TransitionConditionInlineElementTypeContentDeserializerState::St(
                                    values, None,
                                ),
                            )?;
                        *self.state =
                            TransitionConditionInlineElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            TransitionConditionInlineElementTypeContentDeserializerState::St(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_fbd<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::BodyFbdElementType>,
                output: DeserializerOutput<'de, super::BodyFbdElementType>,
                fallback: &mut Option<TransitionConditionInlineElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            * self . state = TransitionConditionInlineElementTypeContentDeserializerState :: Init__ ;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => TransitionConditionInlineElementTypeContentDeserializerState::Fbd(
                            values, None,
                        ),
                        Some(
                            TransitionConditionInlineElementTypeContentDeserializerState::Fbd(
                                _,
                                Some(deserializer),
                            ),
                        ) => TransitionConditionInlineElementTypeContentDeserializerState::Fbd(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(TransitionConditionInlineElementTypeContentDeserializerState::Fbd(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        TransitionConditionInlineElementTypeContentDeserializer::store_fbd(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        TransitionConditionInlineElementTypeContentDeserializer::store_fbd(
                            &mut values,
                            data,
                        )?;
                        let data =
                            TransitionConditionInlineElementTypeContentDeserializer::finish_state(
                                reader,
                                TransitionConditionInlineElementTypeContentDeserializerState::Fbd(
                                    values, None,
                                ),
                            )?;
                        *self.state =
                            TransitionConditionInlineElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            TransitionConditionInlineElementTypeContentDeserializerState::Fbd(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_ld<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::BodyLdElementType>,
                output: DeserializerOutput<'de, super::BodyLdElementType>,
                fallback: &mut Option<TransitionConditionInlineElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            * self . state = TransitionConditionInlineElementTypeContentDeserializerState :: Init__ ;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => TransitionConditionInlineElementTypeContentDeserializerState::Ld(
                            values, None,
                        ),
                        Some(TransitionConditionInlineElementTypeContentDeserializerState::Ld(
                            _,
                            Some(deserializer),
                        )) => TransitionConditionInlineElementTypeContentDeserializerState::Ld(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(TransitionConditionInlineElementTypeContentDeserializerState::Ld(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        TransitionConditionInlineElementTypeContentDeserializer::store_ld(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        TransitionConditionInlineElementTypeContentDeserializer::store_ld(
                            &mut values,
                            data,
                        )?;
                        let data =
                            TransitionConditionInlineElementTypeContentDeserializer::finish_state(
                                reader,
                                TransitionConditionInlineElementTypeContentDeserializerState::Ld(
                                    values, None,
                                ),
                            )?;
                        *self.state =
                            TransitionConditionInlineElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            TransitionConditionInlineElementTypeContentDeserializerState::Ld(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_sfc<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::BodySfcElementType>,
                output: DeserializerOutput<'de, super::BodySfcElementType>,
                fallback: &mut Option<TransitionConditionInlineElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            * self . state = TransitionConditionInlineElementTypeContentDeserializerState :: Init__ ;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => TransitionConditionInlineElementTypeContentDeserializerState::Sfc(
                            values, None,
                        ),
                        Some(
                            TransitionConditionInlineElementTypeContentDeserializerState::Sfc(
                                _,
                                Some(deserializer),
                            ),
                        ) => TransitionConditionInlineElementTypeContentDeserializerState::Sfc(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(TransitionConditionInlineElementTypeContentDeserializerState::Sfc(
                        _,
                        Some(deserializer),
                    )) => {
                        let data = deserializer.finish(reader)?;
                        TransitionConditionInlineElementTypeContentDeserializer::store_sfc(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        TransitionConditionInlineElementTypeContentDeserializer::store_sfc(
                            &mut values,
                            data,
                        )?;
                        let data =
                            TransitionConditionInlineElementTypeContentDeserializer::finish_state(
                                reader,
                                TransitionConditionInlineElementTypeContentDeserializerState::Sfc(
                                    values, None,
                                ),
                            )?;
                        *self.state =
                            TransitionConditionInlineElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            TransitionConditionInlineElementTypeContentDeserializerState::Sfc(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::AddDataType>,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<TransitionConditionInlineElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = match fallback.take() {
                        None if values.is_none() => {
                            * self . state = TransitionConditionInlineElementTypeContentDeserializerState :: Init__ ;
                            return Ok(ElementHandlerOutput::from_event(event, allow_any));
                        }
                        None => {
                            TransitionConditionInlineElementTypeContentDeserializerState::AddData(
                                values, None,
                            )
                        }
                        Some(
                            TransitionConditionInlineElementTypeContentDeserializerState::AddData(
                                _,
                                Some(deserializer),
                            ),
                        ) => TransitionConditionInlineElementTypeContentDeserializerState::AddData(
                            values,
                            Some(deserializer),
                        ),
                        _ => unreachable!(),
                    };
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(
                        TransitionConditionInlineElementTypeContentDeserializerState::AddData(
                            _,
                            Some(deserializer),
                        ),
                    ) => {
                        let data = deserializer.finish(reader)?;
                        TransitionConditionInlineElementTypeContentDeserializer::store_add_data(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        TransitionConditionInlineElementTypeContentDeserializer::store_add_data(
                            &mut values,
                            data,
                        )?;
                        let data = TransitionConditionInlineElementTypeContentDeserializer :: finish_state (reader , TransitionConditionInlineElementTypeContentDeserializerState :: AddData (values , None)) ? ;
                        *self.state =
                            TransitionConditionInlineElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        *self.state =
                            TransitionConditionInlineElementTypeContentDeserializerState::AddData(
                                values,
                                Some(deserializer),
                            );
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::FormattedTextType>,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<TransitionConditionInlineElementTypeContentDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    * self . state = match fallback . take () { None if values . is_none () => { * self . state = TransitionConditionInlineElementTypeContentDeserializerState :: Init__ ; return Ok (ElementHandlerOutput :: from_event (event , allow_any)) ; } , None => TransitionConditionInlineElementTypeContentDeserializerState :: Documentation (values , None) , Some (TransitionConditionInlineElementTypeContentDeserializerState :: Documentation (_ , Some (deserializer))) => TransitionConditionInlineElementTypeContentDeserializerState :: Documentation (values , Some (deserializer)) , _ => unreachable ! () , } ;
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(
                        TransitionConditionInlineElementTypeContentDeserializerState::Documentation(
                            _,
                            Some(deserializer),
                        ),
                    ) => {
                        let data = deserializer.finish(reader)?;
                        TransitionConditionInlineElementTypeContentDeserializer :: store_documentation (& mut values , data) ? ;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        TransitionConditionInlineElementTypeContentDeserializer :: store_documentation (& mut values , data) ? ;
                        let data = TransitionConditionInlineElementTypeContentDeserializer :: finish_state (reader , TransitionConditionInlineElementTypeContentDeserializerState :: Documentation (values , None)) ? ;
                        *self.state =
                            TransitionConditionInlineElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        * self . state = TransitionConditionInlineElementTypeContentDeserializerState :: Documentation (values , Some (deserializer)) ;
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::TransitionConditionInlineElementTypeContent>
            for Box<TransitionConditionInlineElementTypeContentDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::TransitionConditionInlineElementTypeContent>
            where
                R: DeserializeReader,
            {
                let deserializer =
                    Box::new(TransitionConditionInlineElementTypeContentDeserializer {
                        state: Box::new(
                            TransitionConditionInlineElementTypeContentDeserializerState::Init__,
                        ),
                    });
                let mut output = deserializer.next(reader, event)?;
                output.artifact = match output.artifact {
                    DeserializerArtifact::Deserializer(x)
                        if matches!(
                            &*x.state,
                            TransitionConditionInlineElementTypeContentDeserializerState::Init__
                        ) =>
                    {
                        DeserializerArtifact::None
                    }
                    artifact => artifact,
                };
                Ok(output)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::TransitionConditionInlineElementTypeContent>
            where
                R: DeserializeReader,
            {
                use TransitionConditionInlineElementTypeContentDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Il(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_il(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::St(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_st(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Fbd(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_fbd(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Ld(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_ld(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Sfc(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_sfc(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AddData(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Documentation(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (state, event @ Event::End(_)) => {
                            return Ok (DeserializerOutput { artifact : DeserializerArtifact :: Data (TransitionConditionInlineElementTypeContentDeserializer :: finish_state (reader , state) ?) , event : DeserializerEvent :: Continue (event) , allow_any : false , }) ;
                        }
                        (S::Init__, event) => {
                            match self.find_suitable(reader, event, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Il(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"IL",
                                true,
                            )?;
                            match self.handle_il(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::St(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"ST",
                                true,
                            )?;
                            match self.handle_st(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Fbd(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"FBD",
                                false,
                            )?;
                            match self.handle_fbd(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Ld(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"LD",
                                false,
                            )?;
                            match self.handle_ld(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Sfc(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"SFC",
                                false,
                            )?;
                            match self.handle_sfc(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AddData(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Documentation(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (s @ S::Done__(_), event) => {
                            *self.state = s;
                            break (DeserializerEvent::Continue(event), false);
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = if matches!(&*self.state, S::Done__(_)) {
                    DeserializerArtifact::Data(self.finish(reader)?)
                } else {
                    DeserializerArtifact::Deserializer(self)
                };
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                self,
                reader: &R,
            ) -> Result<super::TransitionConditionInlineElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                TransitionConditionInlineElementTypeContentDeserializer::finish_state(
                    reader,
                    *self.state,
                )
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesPousPouInterfaceElementTypeDeserializer {
            content: Vec<super::ProjectTypesPousPouInterfaceElementTypeContent>,
            state: Box<ProjectTypesPousPouInterfaceElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectTypesPousPouInterfaceElementTypeDeserializerState {
            Init__ , Next__ , Content__ (< super :: ProjectTypesPousPouInterfaceElementTypeContent as WithDeserializer > :: Deserializer) , Unknown__ , }
        impl ProjectTypesPousPouInterfaceElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    content: Vec::new(),
                    state: Box::new(
                        ProjectTypesPousPouInterfaceElementTypeDeserializerState::Init__,
                    ),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectTypesPousPouInterfaceElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                if let ProjectTypesPousPouInterfaceElementTypeDeserializerState::Content__(
                    deserializer,
                ) = state
                {
                    self.store_content(deserializer.finish(reader)?)?;
                }
                Ok(())
            }
            fn store_content(
                &mut self,
                value: super::ProjectTypesPousPouInterfaceElementTypeContent,
            ) -> Result<(), Error> {
                self.content.push(value);
                Ok(())
            }
            fn handle_content<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<
                    'de,
                    super::ProjectTypesPousPouInterfaceElementTypeContent,
                >,
                fallback: &mut Option<ProjectTypesPousPouInterfaceElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    *self.state = fallback.take().unwrap_or(
                        ProjectTypesPousPouInterfaceElementTypeDeserializerState::Next__,
                    );
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_content(data)?;
                        *self.state =
                            ProjectTypesPousPouInterfaceElementTypeDeserializerState::Next__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectTypesPousPouInterfaceElementTypeDeserializerState :: Content__ (deserializer) ;
                            }
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectTypesPousPouInterfaceElementTypeDeserializerState :: Content__ (deserializer)) ;
                                * self . state = ProjectTypesPousPouInterfaceElementTypeDeserializerState :: Next__ ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectTypesPousPouInterfaceElementType>
            for Box<ProjectTypesPousPouInterfaceElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesPousPouInterfaceElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ProjectTypesPousPouInterfaceElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesPousPouInterfaceElementType>
            where
                R: DeserializeReader,
            {
                use ProjectTypesPousPouInterfaceElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Content__(deserializer), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (_, Event::End(_)) => {
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (state @ (S::Init__ | S::Next__), event) => {
                            fallback.get_or_insert(state);
                            let output = < super :: ProjectTypesPousPouInterfaceElementTypeContent as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                            match self.handle_content(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = DeserializerArtifact::Deserializer(self);
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ProjectTypesPousPouInterfaceElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ProjectTypesPousPouInterfaceElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ProjectTypesPousPouInterfaceElementType {
                    content: self.content,
                })
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesPousPouInterfaceElementTypeContentDeserializer {
            state: Box<ProjectTypesPousPouInterfaceElementTypeContentDeserializerState>,
        }
        #[derive(Debug)]
        pub enum ProjectTypesPousPouInterfaceElementTypeContentDeserializerState {
            Init__ , ReturnType (Option < super :: DataType > , Option << super :: DataType as WithDeserializer > :: Deserializer >) , LocalVars (Option < super :: ProjectTypesPousPouInterfaceExternalVarsElementType > , Option << super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithDeserializer > :: Deserializer >) , TempVars (Option < super :: ProjectTypesPousPouInterfaceExternalVarsElementType > , Option << super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithDeserializer > :: Deserializer >) , InputVars (Option < super :: ProjectTypesPousPouInterfaceExternalVarsElementType > , Option << super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithDeserializer > :: Deserializer >) , OutputVars (Option < super :: ProjectTypesPousPouInterfaceExternalVarsElementType > , Option << super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithDeserializer > :: Deserializer >) , InOutVars (Option < super :: ProjectTypesPousPouInterfaceExternalVarsElementType > , Option << super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithDeserializer > :: Deserializer >) , ExternalVars (Option < super :: ProjectTypesPousPouInterfaceExternalVarsElementType > , Option << super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithDeserializer > :: Deserializer >) , GlobalVars (Option < super :: ProjectTypesPousPouInterfaceExternalVarsElementType > , Option << super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithDeserializer > :: Deserializer >) , AccessVars (Option < super :: VarListType > , Option << super :: VarListType as WithDeserializer > :: Deserializer >) , AddData (Option < super :: AddDataType > , Option << super :: AddDataType as WithDeserializer > :: Deserializer >) , Documentation (Option < super :: FormattedTextType > , Option << super :: FormattedTextType as WithDeserializer > :: Deserializer >) , Done__ (super :: ProjectTypesPousPouInterfaceElementTypeContent) , Unknown__ , }
        impl ProjectTypesPousPouInterfaceElementTypeContentDeserializer {
            fn find_suitable<'de, R>(
                &mut self,
                reader: &R,
                event: Event<'de>,
                fallback: &mut Option<
                    ProjectTypesPousPouInterfaceElementTypeContentDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                if let Event::Start(x) | Event::Empty(x) = &event {
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"returnType")
                    ) {
                        let output = <super::DataType as WithDeserializer>::Deserializer::init(
                            reader, event,
                        )?;
                        return self.handle_return_type(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"localVars")
                    ) {
                        let output = < super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_local_vars(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"tempVars")
                    ) {
                        let output = < super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_temp_vars(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"inputVars")
                    ) {
                        let output = < super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_input_vars(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"outputVars")
                    ) {
                        let output = < super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_output_vars(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"inOutVars")
                    ) {
                        let output = < super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_in_out_vars(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"externalVars")
                    ) {
                        let output = < super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_external_vars(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"globalVars")
                    ) {
                        let output = < super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithDeserializer > :: Deserializer :: init (reader , event) ? ;
                        return self.handle_global_vars(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"accessVars")
                    ) {
                        let output = <super::VarListType as WithDeserializer>::Deserializer::init(
                            reader, event,
                        )?;
                        return self.handle_access_vars(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"addData")
                    ) {
                        let output = <super::AddDataType as WithDeserializer>::Deserializer::init(
                            reader, event,
                        )?;
                        return self.handle_add_data(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                    if matches!(
                        reader.resolve_local_name(x.name(), &super::super::NS_PPX),
                        Some(b"documentation")
                    ) {
                        let output =
                            <super::FormattedTextType as WithDeserializer>::Deserializer::init(
                                reader, event,
                            )?;
                        return self.handle_documentation(
                            reader,
                            Default::default(),
                            output,
                            &mut *fallback,
                        );
                    }
                }
                *self.state = fallback.take().unwrap_or(
                    ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::Init__,
                );
                Ok(ElementHandlerOutput::return_to_parent(event, false))
            }
            fn finish_state<R>(
                reader: &R,
                state: ProjectTypesPousPouInterfaceElementTypeContentDeserializerState,
            ) -> Result<super::ProjectTypesPousPouInterfaceElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                use ProjectTypesPousPouInterfaceElementTypeContentDeserializerState as S;
                match state {
                    S::Init__ => Err(ErrorKind::MissingContent.into()),
                    S::ReturnType(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_return_type (& mut values , value) ? ;
                        }
                        Ok(
                            super::ProjectTypesPousPouInterfaceElementTypeContent::ReturnType(
                                values.ok_or_else(|| {
                                    ErrorKind::MissingElement("returnType".into())
                                })?,
                            ),
                        )
                    }
                    S::LocalVars(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_local_vars (& mut values , value) ? ;
                        }
                        Ok(
                            super::ProjectTypesPousPouInterfaceElementTypeContent::LocalVars(
                                values
                                    .ok_or_else(|| ErrorKind::MissingElement("localVars".into()))?,
                            ),
                        )
                    }
                    S::TempVars(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_temp_vars (& mut values , value) ? ;
                        }
                        Ok(
                            super::ProjectTypesPousPouInterfaceElementTypeContent::TempVars(
                                values
                                    .ok_or_else(|| ErrorKind::MissingElement("tempVars".into()))?,
                            ),
                        )
                    }
                    S::InputVars(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_input_vars (& mut values , value) ? ;
                        }
                        Ok(
                            super::ProjectTypesPousPouInterfaceElementTypeContent::InputVars(
                                values
                                    .ok_or_else(|| ErrorKind::MissingElement("inputVars".into()))?,
                            ),
                        )
                    }
                    S::OutputVars(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_output_vars (& mut values , value) ? ;
                        }
                        Ok(
                            super::ProjectTypesPousPouInterfaceElementTypeContent::OutputVars(
                                values.ok_or_else(|| {
                                    ErrorKind::MissingElement("outputVars".into())
                                })?,
                            ),
                        )
                    }
                    S::InOutVars(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_in_out_vars (& mut values , value) ? ;
                        }
                        Ok(
                            super::ProjectTypesPousPouInterfaceElementTypeContent::InOutVars(
                                values
                                    .ok_or_else(|| ErrorKind::MissingElement("inOutVars".into()))?,
                            ),
                        )
                    }
                    S::ExternalVars(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_external_vars (& mut values , value) ? ;
                        }
                        Ok(
                            super::ProjectTypesPousPouInterfaceElementTypeContent::ExternalVars(
                                values.ok_or_else(|| {
                                    ErrorKind::MissingElement("externalVars".into())
                                })?,
                            ),
                        )
                    }
                    S::GlobalVars(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_global_vars (& mut values , value) ? ;
                        }
                        Ok(
                            super::ProjectTypesPousPouInterfaceElementTypeContent::GlobalVars(
                                values.ok_or_else(|| {
                                    ErrorKind::MissingElement("globalVars".into())
                                })?,
                            ),
                        )
                    }
                    S::AccessVars(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_access_vars (& mut values , value) ? ;
                        }
                        Ok(
                            super::ProjectTypesPousPouInterfaceElementTypeContent::AccessVars(
                                values.ok_or_else(|| {
                                    ErrorKind::MissingElement("accessVars".into())
                                })?,
                            ),
                        )
                    }
                    S::AddData(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_add_data (& mut values , value) ? ;
                        }
                        Ok(
                            super::ProjectTypesPousPouInterfaceElementTypeContent::AddData(
                                values
                                    .ok_or_else(|| ErrorKind::MissingElement("addData".into()))?,
                            ),
                        )
                    }
                    S::Documentation(mut values, deserializer) => {
                        if let Some(deserializer) = deserializer {
                            let value = deserializer.finish(reader)?;
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_documentation (& mut values , value) ? ;
                        }
                        Ok(
                            super::ProjectTypesPousPouInterfaceElementTypeContent::Documentation(
                                values.ok_or_else(|| {
                                    ErrorKind::MissingElement("documentation".into())
                                })?,
                            ),
                        )
                    }
                    S::Done__(data) => Ok(data),
                    S::Unknown__ => unreachable!(),
                }
            }
            fn store_return_type(
                values: &mut Option<super::DataType>,
                value: super::DataType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"returnType",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_local_vars(
                values: &mut Option<super::ProjectTypesPousPouInterfaceExternalVarsElementType>,
                value: super::ProjectTypesPousPouInterfaceExternalVarsElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"localVars",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_temp_vars(
                values: &mut Option<super::ProjectTypesPousPouInterfaceExternalVarsElementType>,
                value: super::ProjectTypesPousPouInterfaceExternalVarsElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"tempVars",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_input_vars(
                values: &mut Option<super::ProjectTypesPousPouInterfaceExternalVarsElementType>,
                value: super::ProjectTypesPousPouInterfaceExternalVarsElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"inputVars",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_output_vars(
                values: &mut Option<super::ProjectTypesPousPouInterfaceExternalVarsElementType>,
                value: super::ProjectTypesPousPouInterfaceExternalVarsElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"outputVars",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_in_out_vars(
                values: &mut Option<super::ProjectTypesPousPouInterfaceExternalVarsElementType>,
                value: super::ProjectTypesPousPouInterfaceExternalVarsElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"inOutVars",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_external_vars(
                values: &mut Option<super::ProjectTypesPousPouInterfaceExternalVarsElementType>,
                value: super::ProjectTypesPousPouInterfaceExternalVarsElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"externalVars",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_global_vars(
                values: &mut Option<super::ProjectTypesPousPouInterfaceExternalVarsElementType>,
                value: super::ProjectTypesPousPouInterfaceExternalVarsElementType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"globalVars",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_access_vars(
                values: &mut Option<super::VarListType>,
                value: super::VarListType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"accessVars",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_add_data(
                values: &mut Option<super::AddDataType>,
                value: super::AddDataType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn store_documentation(
                values: &mut Option<super::FormattedTextType>,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if values.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                *values = Some(value);
                Ok(())
            }
            fn handle_return_type<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::DataType>,
                output: DeserializerOutput<'de, super::DataType>,
                fallback: &mut Option<
                    ProjectTypesPousPouInterfaceElementTypeContentDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    * self . state = match fallback . take () { None if values . is_none () => { * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: Init__ ; return Ok (ElementHandlerOutput :: from_event (event , allow_any)) ; } , None => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: ReturnType (values , None) , Some (ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: ReturnType (_ , Some (deserializer))) => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: ReturnType (values , Some (deserializer)) , _ => unreachable ! () , } ;
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::ReturnType(
                            _,
                            Some(deserializer),
                        ),
                    ) => {
                        let data = deserializer.finish(reader)?;
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_return_type (& mut values , data) ? ;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_return_type (& mut values , data) ? ;
                        let data = ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: finish_state (reader , ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: ReturnType (values , None)) ? ;
                        *self.state =
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: ReturnType (values , Some (deserializer)) ;
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_local_vars<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ProjectTypesPousPouInterfaceExternalVarsElementType>,
                output: DeserializerOutput<
                    'de,
                    super::ProjectTypesPousPouInterfaceExternalVarsElementType,
                >,
                fallback: &mut Option<
                    ProjectTypesPousPouInterfaceElementTypeContentDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    * self . state = match fallback . take () { None if values . is_none () => { * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: Init__ ; return Ok (ElementHandlerOutput :: from_event (event , allow_any)) ; } , None => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: LocalVars (values , None) , Some (ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: LocalVars (_ , Some (deserializer))) => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: LocalVars (values , Some (deserializer)) , _ => unreachable ! () , } ;
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::LocalVars(
                            _,
                            Some(deserializer),
                        ),
                    ) => {
                        let data = deserializer.finish(reader)?;
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_local_vars (& mut values , data) ? ;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_local_vars (& mut values , data) ? ;
                        let data = ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: finish_state (reader , ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: LocalVars (values , None)) ? ;
                        *self.state =
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: LocalVars (values , Some (deserializer)) ;
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_temp_vars<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ProjectTypesPousPouInterfaceExternalVarsElementType>,
                output: DeserializerOutput<
                    'de,
                    super::ProjectTypesPousPouInterfaceExternalVarsElementType,
                >,
                fallback: &mut Option<
                    ProjectTypesPousPouInterfaceElementTypeContentDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    * self . state = match fallback . take () { None if values . is_none () => { * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: Init__ ; return Ok (ElementHandlerOutput :: from_event (event , allow_any)) ; } , None => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: TempVars (values , None) , Some (ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: TempVars (_ , Some (deserializer))) => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: TempVars (values , Some (deserializer)) , _ => unreachable ! () , } ;
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::TempVars(
                            _,
                            Some(deserializer),
                        ),
                    ) => {
                        let data = deserializer.finish(reader)?;
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_temp_vars (& mut values , data) ? ;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_temp_vars (& mut values , data) ? ;
                        let data = ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: finish_state (reader , ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: TempVars (values , None)) ? ;
                        *self.state =
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: TempVars (values , Some (deserializer)) ;
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_input_vars<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ProjectTypesPousPouInterfaceExternalVarsElementType>,
                output: DeserializerOutput<
                    'de,
                    super::ProjectTypesPousPouInterfaceExternalVarsElementType,
                >,
                fallback: &mut Option<
                    ProjectTypesPousPouInterfaceElementTypeContentDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    * self . state = match fallback . take () { None if values . is_none () => { * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: Init__ ; return Ok (ElementHandlerOutput :: from_event (event , allow_any)) ; } , None => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: InputVars (values , None) , Some (ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: InputVars (_ , Some (deserializer))) => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: InputVars (values , Some (deserializer)) , _ => unreachable ! () , } ;
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::InputVars(
                            _,
                            Some(deserializer),
                        ),
                    ) => {
                        let data = deserializer.finish(reader)?;
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_input_vars (& mut values , data) ? ;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_input_vars (& mut values , data) ? ;
                        let data = ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: finish_state (reader , ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: InputVars (values , None)) ? ;
                        *self.state =
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: InputVars (values , Some (deserializer)) ;
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_output_vars<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ProjectTypesPousPouInterfaceExternalVarsElementType>,
                output: DeserializerOutput<
                    'de,
                    super::ProjectTypesPousPouInterfaceExternalVarsElementType,
                >,
                fallback: &mut Option<
                    ProjectTypesPousPouInterfaceElementTypeContentDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    * self . state = match fallback . take () { None if values . is_none () => { * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: Init__ ; return Ok (ElementHandlerOutput :: from_event (event , allow_any)) ; } , None => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: OutputVars (values , None) , Some (ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: OutputVars (_ , Some (deserializer))) => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: OutputVars (values , Some (deserializer)) , _ => unreachable ! () , } ;
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::OutputVars(
                            _,
                            Some(deserializer),
                        ),
                    ) => {
                        let data = deserializer.finish(reader)?;
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_output_vars (& mut values , data) ? ;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_output_vars (& mut values , data) ? ;
                        let data = ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: finish_state (reader , ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: OutputVars (values , None)) ? ;
                        *self.state =
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: OutputVars (values , Some (deserializer)) ;
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_in_out_vars<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ProjectTypesPousPouInterfaceExternalVarsElementType>,
                output: DeserializerOutput<
                    'de,
                    super::ProjectTypesPousPouInterfaceExternalVarsElementType,
                >,
                fallback: &mut Option<
                    ProjectTypesPousPouInterfaceElementTypeContentDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    * self . state = match fallback . take () { None if values . is_none () => { * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: Init__ ; return Ok (ElementHandlerOutput :: from_event (event , allow_any)) ; } , None => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: InOutVars (values , None) , Some (ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: InOutVars (_ , Some (deserializer))) => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: InOutVars (values , Some (deserializer)) , _ => unreachable ! () , } ;
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::InOutVars(
                            _,
                            Some(deserializer),
                        ),
                    ) => {
                        let data = deserializer.finish(reader)?;
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_in_out_vars (& mut values , data) ? ;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_in_out_vars (& mut values , data) ? ;
                        let data = ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: finish_state (reader , ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: InOutVars (values , None)) ? ;
                        *self.state =
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: InOutVars (values , Some (deserializer)) ;
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_external_vars<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ProjectTypesPousPouInterfaceExternalVarsElementType>,
                output: DeserializerOutput<
                    'de,
                    super::ProjectTypesPousPouInterfaceExternalVarsElementType,
                >,
                fallback: &mut Option<
                    ProjectTypesPousPouInterfaceElementTypeContentDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    * self . state = match fallback . take () { None if values . is_none () => { * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: Init__ ; return Ok (ElementHandlerOutput :: from_event (event , allow_any)) ; } , None => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: ExternalVars (values , None) , Some (ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: ExternalVars (_ , Some (deserializer))) => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: ExternalVars (values , Some (deserializer)) , _ => unreachable ! () , } ;
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback . take () { None => () , Some (ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: ExternalVars (_ , Some (deserializer))) => { let data = deserializer . finish (reader) ? ; ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_external_vars (& mut values , data) ? ; } Some (_) => unreachable ! () , }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_external_vars (& mut values , data) ? ;
                        let data = ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: finish_state (reader , ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: ExternalVars (values , None)) ? ;
                        *self.state =
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: ExternalVars (values , Some (deserializer)) ;
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_global_vars<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::ProjectTypesPousPouInterfaceExternalVarsElementType>,
                output: DeserializerOutput<
                    'de,
                    super::ProjectTypesPousPouInterfaceExternalVarsElementType,
                >,
                fallback: &mut Option<
                    ProjectTypesPousPouInterfaceElementTypeContentDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    * self . state = match fallback . take () { None if values . is_none () => { * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: Init__ ; return Ok (ElementHandlerOutput :: from_event (event , allow_any)) ; } , None => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: GlobalVars (values , None) , Some (ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: GlobalVars (_ , Some (deserializer))) => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: GlobalVars (values , Some (deserializer)) , _ => unreachable ! () , } ;
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::GlobalVars(
                            _,
                            Some(deserializer),
                        ),
                    ) => {
                        let data = deserializer.finish(reader)?;
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_global_vars (& mut values , data) ? ;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_global_vars (& mut values , data) ? ;
                        let data = ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: finish_state (reader , ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: GlobalVars (values , None)) ? ;
                        *self.state =
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: GlobalVars (values , Some (deserializer)) ;
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_access_vars<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::VarListType>,
                output: DeserializerOutput<'de, super::VarListType>,
                fallback: &mut Option<
                    ProjectTypesPousPouInterfaceElementTypeContentDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    * self . state = match fallback . take () { None if values . is_none () => { * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: Init__ ; return Ok (ElementHandlerOutput :: from_event (event , allow_any)) ; } , None => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: AccessVars (values , None) , Some (ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: AccessVars (_ , Some (deserializer))) => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: AccessVars (values , Some (deserializer)) , _ => unreachable ! () , } ;
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::AccessVars(
                            _,
                            Some(deserializer),
                        ),
                    ) => {
                        let data = deserializer.finish(reader)?;
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_access_vars (& mut values , data) ? ;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_access_vars (& mut values , data) ? ;
                        let data = ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: finish_state (reader , ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: AccessVars (values , None)) ? ;
                        *self.state =
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: AccessVars (values , Some (deserializer)) ;
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::AddDataType>,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<
                    ProjectTypesPousPouInterfaceElementTypeContentDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    * self . state = match fallback . take () { None if values . is_none () => { * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: Init__ ; return Ok (ElementHandlerOutput :: from_event (event , allow_any)) ; } , None => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: AddData (values , None) , Some (ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: AddData (_ , Some (deserializer))) => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: AddData (values , Some (deserializer)) , _ => unreachable ! () , } ;
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback.take() {
                    None => (),
                    Some(
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::AddData(
                            _,
                            Some(deserializer),
                        ),
                    ) => {
                        let data = deserializer.finish(reader)?;
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer::store_add_data(
                            &mut values,
                            data,
                        )?;
                    }
                    Some(_) => unreachable!(),
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer::store_add_data(
                            &mut values,
                            data,
                        )?;
                        let data = ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: finish_state (reader , ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: AddData (values , None)) ? ;
                        *self.state =
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: AddData (values , Some (deserializer)) ;
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                mut values: Option<super::FormattedTextType>,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<
                    ProjectTypesPousPouInterfaceElementTypeContentDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    * self . state = match fallback . take () { None if values . is_none () => { * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: Init__ ; return Ok (ElementHandlerOutput :: from_event (event , allow_any)) ; } , None => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: Documentation (values , None) , Some (ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: Documentation (_ , Some (deserializer))) => ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: Documentation (values , Some (deserializer)) , _ => unreachable ! () , } ;
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                match fallback . take () { None => () , Some (ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: Documentation (_ , Some (deserializer))) => { let data = deserializer . finish (reader) ? ; ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_documentation (& mut values , data) ? ; } Some (_) => unreachable ! () , }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: store_documentation (& mut values , data) ? ;
                        let data = ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: finish_state (reader , ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: Documentation (values , None)) ? ;
                        *self.state =
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::Done__(
                                data,
                            );
                        ElementHandlerOutput::Break { event, allow_any }
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        * self . state = ProjectTypesPousPouInterfaceElementTypeContentDeserializerState :: Documentation (values , Some (deserializer)) ;
                        ElementHandlerOutput::from_event_end(event, allow_any)
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectTypesPousPouInterfaceElementTypeContent>
            for Box<ProjectTypesPousPouInterfaceElementTypeContentDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesPousPouInterfaceElementTypeContent>
            where
                R: DeserializeReader,
            {
                let deserializer =
                    Box::new(ProjectTypesPousPouInterfaceElementTypeContentDeserializer {
                        state: Box::new(
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::Init__,
                        ),
                    });
                let mut output = deserializer.next(reader, event)?;
                output.artifact = match output.artifact {
                    DeserializerArtifact::Deserializer(x)
                        if matches!(
                            &*x.state,
                            ProjectTypesPousPouInterfaceElementTypeContentDeserializerState::Init__
                        ) =>
                    {
                        DeserializerArtifact::None
                    }
                    artifact => artifact,
                };
                Ok(output)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesPousPouInterfaceElementTypeContent>
            where
                R: DeserializeReader,
            {
                use ProjectTypesPousPouInterfaceElementTypeContentDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::ReturnType(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_return_type(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::LocalVars(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_local_vars(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::TempVars(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_temp_vars(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::InputVars(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_input_vars(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::OutputVars(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_output_vars(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::InOutVars(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_in_out_vars(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::ExternalVars(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_external_vars(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::GlobalVars(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_global_vars(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AccessVars(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_access_vars(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AddData(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Documentation(values, Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (state, event @ Event::End(_)) => {
                            return Ok (DeserializerOutput { artifact : DeserializerArtifact :: Data (ProjectTypesPousPouInterfaceElementTypeContentDeserializer :: finish_state (reader , state) ?) , event : DeserializerEvent :: Continue (event) , allow_any : false , }) ;
                        }
                        (S::Init__, event) => {
                            match self.find_suitable(reader, event, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::ReturnType(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"returnType",
                                true,
                            )?;
                            match self.handle_return_type(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::LocalVars(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"localVars",
                                true,
                            )?;
                            match self.handle_local_vars(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::TempVars(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"tempVars",
                                true,
                            )?;
                            match self.handle_temp_vars(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::InputVars(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"inputVars",
                                true,
                            )?;
                            match self.handle_input_vars(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::OutputVars(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"outputVars",
                                true,
                            )?;
                            match self.handle_output_vars(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::InOutVars(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"inOutVars",
                                true,
                            )?;
                            match self.handle_in_out_vars(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::ExternalVars(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"externalVars",
                                true,
                            )?;
                            match self.handle_external_vars(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::GlobalVars(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"globalVars",
                                true,
                            )?;
                            match self.handle_global_vars(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AccessVars(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"accessVars",
                                true,
                            )?;
                            match self.handle_access_vars(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::AddData(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, values, output, &mut fallback)? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (S::Documentation(values, None), event) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(
                                reader,
                                values,
                                output,
                                &mut fallback,
                            )? {
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                                ElementHandlerOutput::Continue { event, .. } => event,
                            }
                        }
                        (s @ S::Done__(_), event) => {
                            *self.state = s;
                            break (DeserializerEvent::Continue(event), false);
                        }
                        (S::Unknown__, _) => unreachable!(),
                    }
                };
                let artifact = if matches!(&*self.state, S::Done__(_)) {
                    DeserializerArtifact::Data(self.finish(reader)?)
                } else {
                    DeserializerArtifact::Deserializer(self)
                };
                Ok(DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                self,
                reader: &R,
            ) -> Result<super::ProjectTypesPousPouInterfaceElementTypeContent, Error>
            where
                R: DeserializeReader,
            {
                ProjectTypesPousPouInterfaceElementTypeContentDeserializer::finish_state(
                    reader,
                    *self.state,
                )
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesPousPouActionsElementTypeDeserializer {
            action: Vec<super::ProjectTypesPousPouActionsActionElementType>,
            state: Box<ProjectTypesPousPouActionsElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectTypesPousPouActionsElementTypeDeserializerState {
            Init__ , Action (Option << super :: ProjectTypesPousPouActionsActionElementType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl ProjectTypesPousPouActionsElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    action: Vec::new(),
                    state: Box::new(ProjectTypesPousPouActionsElementTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectTypesPousPouActionsElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectTypesPousPouActionsElementTypeDeserializerState as S;
                match state {
                    S::Action(Some(deserializer)) => {
                        self.store_action(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_action(
                &mut self,
                value: super::ProjectTypesPousPouActionsActionElementType,
            ) -> Result<(), Error> {
                self.action.push(value);
                Ok(())
            }
            fn handle_action<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ProjectTypesPousPouActionsActionElementType>,
                fallback: &mut Option<ProjectTypesPousPouActionsElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectTypesPousPouActionsElementTypeDeserializerState::Action(None),
                    );
                    *self.state = ProjectTypesPousPouActionsElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_action(data)?;
                        *self.state =
                            ProjectTypesPousPouActionsElementTypeDeserializerState::Action(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(
                                    ProjectTypesPousPouActionsElementTypeDeserializerState::Action(
                                        Some(deserializer),
                                    ),
                                );
                                *self.state =
                                    ProjectTypesPousPouActionsElementTypeDeserializerState::Action(
                                        None,
                                    );
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state =
                                    ProjectTypesPousPouActionsElementTypeDeserializerState::Action(
                                        Some(deserializer),
                                    );
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectTypesPousPouActionsElementType>
            for Box<ProjectTypesPousPouActionsElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesPousPouActionsElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ProjectTypesPousPouActionsElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesPousPouActionsElementType>
            where
                R: DeserializeReader,
            {
                use ProjectTypesPousPouActionsElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Action(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_action(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                ProjectTypesPousPouActionsElementTypeDeserializerState::Action(
                                    None,
                                );
                            event
                        }
                        (S::Action(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"action",
                                true,
                            )?;
                            match self.handle_action(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ProjectTypesPousPouActionsElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ProjectTypesPousPouActionsElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ProjectTypesPousPouActionsElementType {
                    action: self.action,
                })
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesPousPouTransitionsElementTypeDeserializer {
            transition: Vec<super::ProjectTypesPousPouActionsActionElementType>,
            state: Box<ProjectTypesPousPouTransitionsElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectTypesPousPouTransitionsElementTypeDeserializerState {
            Init__ , Transition (Option << super :: ProjectTypesPousPouActionsActionElementType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl ProjectTypesPousPouTransitionsElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    reader.raise_unexpected_attrib_checked(attrib)?;
                }
                Ok(Box::new(Self {
                    transition: Vec::new(),
                    state: Box::new(
                        ProjectTypesPousPouTransitionsElementTypeDeserializerState::Init__,
                    ),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectTypesPousPouTransitionsElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectTypesPousPouTransitionsElementTypeDeserializerState as S;
                match state {
                    S::Transition(Some(deserializer)) => {
                        self.store_transition(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_transition(
                &mut self,
                value: super::ProjectTypesPousPouActionsActionElementType,
            ) -> Result<(), Error> {
                self.transition.push(value);
                Ok(())
            }
            fn handle_transition<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::ProjectTypesPousPouActionsActionElementType>,
                fallback: &mut Option<ProjectTypesPousPouTransitionsElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectTypesPousPouTransitionsElementTypeDeserializerState::Transition(
                            None,
                        ),
                    );
                    *self.state =
                        ProjectTypesPousPouTransitionsElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_transition(data)?;
                        *self.state =
                            ProjectTypesPousPouTransitionsElementTypeDeserializerState::Transition(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectTypesPousPouTransitionsElementTypeDeserializerState :: Transition (Some (deserializer))) ;
                                * self . state = ProjectTypesPousPouTransitionsElementTypeDeserializerState :: Transition (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectTypesPousPouTransitionsElementTypeDeserializerState :: Transition (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectTypesPousPouTransitionsElementType>
            for Box<ProjectTypesPousPouTransitionsElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesPousPouTransitionsElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ProjectTypesPousPouTransitionsElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesPousPouTransitionsElementType>
            where
                R: DeserializeReader,
            {
                use ProjectTypesPousPouTransitionsElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Transition(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_transition(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            * self . state = ProjectTypesPousPouTransitionsElementTypeDeserializerState :: Transition (None) ;
                            event
                        }
                        (S::Transition(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"transition",
                                true,
                            )?;
                            match self.handle_transition(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ProjectTypesPousPouTransitionsElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ProjectTypesPousPouTransitionsElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ProjectTypesPousPouTransitionsElementType {
                    transition: self.transition,
                })
            }
        }
        #[derive(Debug)]
        pub struct ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializer {
            name: ::std::string::String,
            global_id: Option<::std::string::String>,
            task: Vec<super::ProjectInstancesConfigurationsConfigurationResourceTaskElementType>,
            global_vars: Vec<super::VarListType>,
            pou_instance: Vec<super::PouInstanceType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<
                ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState,
            >,
        }
        #[derive(Debug)]
        enum ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState {
            Init__ , Task (Option << super :: ProjectInstancesConfigurationsConfigurationResourceTaskElementType as WithDeserializer > :: Deserializer >) , GlobalVars (Option << super :: VarListType as WithDeserializer > :: Deserializer >) , PouInstance (Option << super :: PouInstanceType as WithDeserializer > :: Deserializer >) , AddData (Option << super :: AddDataType as WithDeserializer > :: Deserializer >) , Documentation (Option << super :: FormattedTextType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
        impl ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok (Box :: new (Self { name : name . ok_or_else (|| reader . map_error (ErrorKind :: MissingAttribute ("name" . into ()))) ? , global_id : global_id , task : Vec :: new () , global_vars : Vec :: new () , pou_instance : Vec :: new () , add_data : None , documentation : None , state : Box :: new (ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: Init__) , }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state : ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState as S;
                match state {
                    S::Task(Some(deserializer)) => self.store_task(deserializer.finish(reader)?)?,
                    S::GlobalVars(Some(deserializer)) => {
                        self.store_global_vars(deserializer.finish(reader)?)?
                    }
                    S::PouInstance(Some(deserializer)) => {
                        self.store_pou_instance(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_task(
                &mut self,
                value: super::ProjectInstancesConfigurationsConfigurationResourceTaskElementType,
            ) -> Result<(), Error> {
                self.task.push(value);
                Ok(())
            }
            fn store_global_vars(&mut self, value: super::VarListType) -> Result<(), Error> {
                self.global_vars.push(value);
                Ok(())
            }
            fn store_pou_instance(&mut self, value: super::PouInstanceType) -> Result<(), Error> {
                self.pou_instance.push(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_task<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<
                    'de,
                    super::ProjectInstancesConfigurationsConfigurationResourceTaskElementType,
                >,
                fallback: &mut Option<
                    ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: Task (None)) ;
                    * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: GlobalVars (None) ;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_task(data)?;
                        * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: Task (None) ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: Task (Some (deserializer))) ;
                                * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: Task (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: Task (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_global_vars<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::VarListType>,
                fallback: &mut Option<
                    ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: GlobalVars (None)) ;
                    * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: PouInstance (None) ;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_global_vars(data)?;
                        * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: GlobalVars (None) ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: GlobalVars (Some (deserializer))) ;
                                * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: GlobalVars (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: GlobalVars (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_pou_instance<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PouInstanceType>,
                fallback: &mut Option<
                    ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: PouInstance (None)) ;
                    * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: AddData (None) ;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_pou_instance(data)?;
                        * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: PouInstance (None) ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: PouInstance (Some (deserializer))) ;
                                * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: PouInstance (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: PouInstance (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<
                    ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: AddData (None)) ;
                    * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: Documentation (None) ;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: Documentation (None) ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: AddData (Some (deserializer))) ;
                                * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: Documentation (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: AddData (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<
                    ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: Documentation (None)) ;
                    * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: Done__ ;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: Done__ ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: Documentation (Some (deserializer))) ;
                                * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: Done__ ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: Documentation (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de>
            Deserializer<'de, super::ProjectInstancesConfigurationsConfigurationResourceElementType>
            for Box<ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<
                'de,
                super::ProjectInstancesConfigurationsConfigurationResourceElementType,
            >
            where
                R: DeserializeReader,
            {
                reader . init_deserializer_from_start_event (event , ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializer :: from_bytes_start)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<
                'de,
                super::ProjectInstancesConfigurationsConfigurationResourceElementType,
            >
            where
                R: DeserializeReader,
            {
                use ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Task(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_task(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::GlobalVars(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_global_vars(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::PouInstance(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_pou_instance(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: Task (None) ;
                            event
                        }
                        (S::Task(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"task",
                                true,
                            )?;
                            match self.handle_task(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::GlobalVars(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"globalVars",
                                true,
                            )?;
                            match self.handle_global_vars(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::PouInstance(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"pouInstance",
                                true,
                            )?;
                            match self.handle_pou_instance(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ProjectInstancesConfigurationsConfigurationResourceElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace (& mut * self . state , ProjectInstancesConfigurationsConfigurationResourceElementTypeDeserializerState :: Unknown__) ;
                self.finish_state(reader, state)?;
                Ok(
                    super::ProjectInstancesConfigurationsConfigurationResourceElementType {
                        name: self.name,
                        global_id: self.global_id,
                        task: self.task,
                        global_vars: self.global_vars,
                        pou_instance: self.pou_instance,
                        add_data: self.add_data,
                        documentation: self.documentation,
                    },
                )
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializer {
            name: Option<::std::string::String>,
            constant: ::core::primitive::bool,
            retain: ::core::primitive::bool,
            nonretain: ::core::primitive::bool,
            persistent: ::core::primitive::bool,
            nonpersistent: ::core::primitive::bool,
            variable: Vec<super::VarListPlainVariableElementType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState {
            Init__,
            Variable(
                Option<<super::VarListPlainVariableElementType as WithDeserializer>::Deserializer>,
            ),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                let mut constant: Option<::core::primitive::bool> = None;
                let mut retain: Option<::core::primitive::bool> = None;
                let mut nonretain: Option<::core::primitive::bool> = None;
                let mut persistent: Option<::core::primitive::bool> = None;
                let mut nonpersistent: Option<::core::primitive::bool> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"constant")
                    ) {
                        reader.read_attrib(&mut constant, b"constant", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"retain")
                    ) {
                        reader.read_attrib(&mut retain, b"retain", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"nonretain")
                    ) {
                        reader.read_attrib(&mut nonretain, b"nonretain", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"persistent")
                    ) {
                        reader.read_attrib(&mut persistent, b"persistent", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"nonpersistent")
                    ) {
                        reader.read_attrib(&mut nonpersistent, b"nonpersistent", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok (Box :: new (Self { name : name , constant : constant . unwrap_or_else (super :: ProjectTypesPousPouInterfaceExternalVarsElementType :: default_constant) , retain : retain . unwrap_or_else (super :: ProjectTypesPousPouInterfaceExternalVarsElementType :: default_retain) , nonretain : nonretain . unwrap_or_else (super :: ProjectTypesPousPouInterfaceExternalVarsElementType :: default_nonretain) , persistent : persistent . unwrap_or_else (super :: ProjectTypesPousPouInterfaceExternalVarsElementType :: default_persistent) , nonpersistent : nonpersistent . unwrap_or_else (super :: ProjectTypesPousPouInterfaceExternalVarsElementType :: default_nonpersistent) , variable : Vec :: new () , add_data : None , documentation : None , state : Box :: new (ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: Init__) , }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState as S;
                match state {
                    S::Variable(Some(deserializer)) => {
                        self.store_variable(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_variable(
                &mut self,
                value: super::VarListPlainVariableElementType,
            ) -> Result<(), Error> {
                self.variable.push(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_variable<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::VarListPlainVariableElementType>,
                fallback: &mut Option<
                    ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: Variable (None)) ;
                    * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: AddData (None) ;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_variable(data)?;
                        * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: Variable (None) ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: Variable (Some (deserializer))) ;
                                * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: Variable (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: Variable (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<
                    ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: AddData (None)) ;
                    * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: Documentation (None) ;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: Documentation (None) ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: AddData (Some (deserializer))) ;
                                * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: Documentation (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: AddData (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<
                    ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState,
                >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: Documentation (None)) ;
                    * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: Done__ ;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: Done__ ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: Documentation (Some (deserializer))) ;
                                * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: Done__ ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: Documentation (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectTypesPousPouInterfaceExternalVarsElementType>
            for Box<ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesPousPouInterfaceExternalVarsElementType>
            where
                R: DeserializeReader,
            {
                reader . init_deserializer_from_start_event (event , ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializer :: from_bytes_start)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesPousPouInterfaceExternalVarsElementType>
            where
                R: DeserializeReader,
            {
                use ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Variable(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState :: Variable (None) ;
                            event
                        }
                        (S::Variable(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"variable",
                                true,
                            )?;
                            match self.handle_variable(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ProjectTypesPousPouInterfaceExternalVarsElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ProjectTypesPousPouInterfaceExternalVarsElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ProjectTypesPousPouInterfaceExternalVarsElementType {
                    name: self.name,
                    constant: self.constant,
                    retain: self.retain,
                    nonretain: self.nonretain,
                    persistent: self.persistent,
                    nonpersistent: self.nonpersistent,
                    variable: self.variable,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesPousPouActionsActionElementTypeDeserializer {
            name: ::std::string::String,
            global_id: Option<::std::string::String>,
            body: Option<super::BodyType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<ProjectTypesPousPouActionsActionElementTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum ProjectTypesPousPouActionsActionElementTypeDeserializerState {
            Init__,
            Body(Option<<super::BodyType as WithDeserializer>::Deserializer>),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl ProjectTypesPousPouActionsActionElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok(Box::new(Self {
                    name: name.ok_or_else(|| {
                        reader.map_error(ErrorKind::MissingAttribute("name".into()))
                    })?,
                    global_id: global_id,
                    body: None,
                    add_data: None,
                    documentation: None,
                    state: Box::new(
                        ProjectTypesPousPouActionsActionElementTypeDeserializerState::Init__,
                    ),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: ProjectTypesPousPouActionsActionElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectTypesPousPouActionsActionElementTypeDeserializerState as S;
                match state {
                    S::Body(Some(deserializer)) => self.store_body(deserializer.finish(reader)?)?,
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_body(&mut self, value: super::BodyType) -> Result<(), Error> {
                if self.body.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"body")))?;
                }
                self.body = Some(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_body<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::BodyType>,
                fallback: &mut Option<ProjectTypesPousPouActionsActionElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    if self.body.is_some() {
                        fallback.get_or_insert(
                            ProjectTypesPousPouActionsActionElementTypeDeserializerState::Body(
                                None,
                            ),
                        );
                        *self.state =
                            ProjectTypesPousPouActionsActionElementTypeDeserializerState::AddData(
                                None,
                            );
                        return Ok(ElementHandlerOutput::from_event(event, allow_any));
                    } else {
                        *self.state =
                            ProjectTypesPousPouActionsActionElementTypeDeserializerState::Body(
                                None,
                            );
                        return Ok(ElementHandlerOutput::break_(event, allow_any));
                    }
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_body(data)?;
                        *self.state =
                            ProjectTypesPousPouActionsActionElementTypeDeserializerState::AddData(
                                None,
                            );
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectTypesPousPouActionsActionElementTypeDeserializerState :: Body (Some (deserializer))) ;
                                * self . state = ProjectTypesPousPouActionsActionElementTypeDeserializerState :: AddData (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectTypesPousPouActionsActionElementTypeDeserializerState :: Body (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback: &mut Option<ProjectTypesPousPouActionsActionElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectTypesPousPouActionsActionElementTypeDeserializerState::AddData(None),
                    );
                    *self.state =
                        ProjectTypesPousPouActionsActionElementTypeDeserializerState::Documentation(
                            None,
                        );
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        * self . state = ProjectTypesPousPouActionsActionElementTypeDeserializerState :: Documentation (None) ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectTypesPousPouActionsActionElementTypeDeserializerState :: AddData (Some (deserializer))) ;
                                * self . state = ProjectTypesPousPouActionsActionElementTypeDeserializerState :: Documentation (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectTypesPousPouActionsActionElementTypeDeserializerState :: AddData (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback: &mut Option<ProjectTypesPousPouActionsActionElementTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(
                        ProjectTypesPousPouActionsActionElementTypeDeserializerState::Documentation(
                            None,
                        ),
                    );
                    *self.state =
                        ProjectTypesPousPouActionsActionElementTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        *self.state =
                            ProjectTypesPousPouActionsActionElementTypeDeserializerState::Done__;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectTypesPousPouActionsActionElementTypeDeserializerState :: Documentation (Some (deserializer))) ;
                                * self . state = ProjectTypesPousPouActionsActionElementTypeDeserializerState :: Done__ ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectTypesPousPouActionsActionElementTypeDeserializerState :: Documentation (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::ProjectTypesPousPouActionsActionElementType>
            for Box<ProjectTypesPousPouActionsActionElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesPousPouActionsActionElementType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    ProjectTypesPousPouActionsActionElementTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::ProjectTypesPousPouActionsActionElementType>
            where
                R: DeserializeReader,
            {
                use ProjectTypesPousPouActionsActionElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Body(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_body(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state =
                                ProjectTypesPousPouActionsActionElementTypeDeserializerState::Body(
                                    None,
                                );
                            event
                        }
                        (S::Body(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"body",
                                true,
                            )?;
                            match self.handle_body(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<super::ProjectTypesPousPouActionsActionElementType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(
                    &mut *self.state,
                    ProjectTypesPousPouActionsActionElementTypeDeserializerState::Unknown__,
                );
                self.finish_state(reader, state)?;
                Ok(super::ProjectTypesPousPouActionsActionElementType {
                    name: self.name,
                    global_id: self.global_id,
                    body: self
                        .body
                        .ok_or_else(|| ErrorKind::MissingElement("body".into()))?,
                    add_data: self.add_data,
                    documentation: self.documentation,
                })
            }
        }
        #[derive(Debug)]
        pub struct ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializer {
            name: ::std::string::String,
            single: Option<::std::string::String>,
            interval: Option<::std::string::String>,
            priority: BigInt,
            global_id: Option<::std::string::String>,
            pou_instance: Vec<super::PouInstanceType>,
            add_data: Option<super::AddDataType>,
            documentation: Option<super::FormattedTextType>,
            state: Box<
                ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState,
            >,
        }
        #[derive(Debug)]
        enum ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState {
            Init__,
            PouInstance(Option<<super::PouInstanceType as WithDeserializer>::Deserializer>),
            AddData(Option<<super::AddDataType as WithDeserializer>::Deserializer>),
            Documentation(Option<<super::FormattedTextType as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut name: Option<::std::string::String> = None;
                let mut single: Option<::std::string::String> = None;
                let mut interval: Option<::std::string::String> = None;
                let mut priority: Option<BigInt> = None;
                let mut global_id: Option<::std::string::String> = None;
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"name")
                    ) {
                        reader.read_attrib(&mut name, b"name", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"single")
                    ) {
                        reader.read_attrib(&mut single, b"single", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"interval")
                    ) {
                        reader.read_attrib(&mut interval, b"interval", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"priority")
                    ) {
                        reader.read_attrib(&mut priority, b"priority", &attrib.value)?;
                    } else if matches!(
                        reader.resolve_local_name(attrib.key, &super::super::NS_PPX),
                        Some(b"globalId")
                    ) {
                        reader.read_attrib(&mut global_id, b"globalId", &attrib.value)?;
                    } else {
                        reader.raise_unexpected_attrib_checked(attrib)?;
                    }
                }
                Ok (Box :: new (Self { name : name . ok_or_else (|| reader . map_error (ErrorKind :: MissingAttribute ("name" . into ()))) ? , single : single , interval : interval , priority : priority . ok_or_else (|| reader . map_error (ErrorKind :: MissingAttribute ("priority" . into ()))) ? , global_id : global_id , pou_instance : Vec :: new () , add_data : None , documentation : None , state : Box :: new (ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: Init__) , }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state : ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState as S;
                match state {
                    S::PouInstance(Some(deserializer)) => {
                        self.store_pou_instance(deserializer.finish(reader)?)?
                    }
                    S::AddData(Some(deserializer)) => {
                        self.store_add_data(deserializer.finish(reader)?)?
                    }
                    S::Documentation(Some(deserializer)) => {
                        self.store_documentation(deserializer.finish(reader)?)?
                    }
                    _ => (),
                }
                Ok(())
            }
            fn store_pou_instance(&mut self, value: super::PouInstanceType) -> Result<(), Error> {
                self.pou_instance.push(value);
                Ok(())
            }
            fn store_add_data(&mut self, value: super::AddDataType) -> Result<(), Error> {
                if self.add_data.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"addData",
                    )))?;
                }
                self.add_data = Some(value);
                Ok(())
            }
            fn store_documentation(
                &mut self,
                value: super::FormattedTextType,
            ) -> Result<(), Error> {
                if self.documentation.is_some() {
                    Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                        b"documentation",
                    )))?;
                }
                self.documentation = Some(value);
                Ok(())
            }
            fn handle_pou_instance<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::PouInstanceType>,
                fallback : & mut Option < ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: PouInstance (None)) ;
                    * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: AddData (None) ;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_pou_instance(data)?;
                        * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: PouInstance (None) ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: PouInstance (Some (deserializer))) ;
                                * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: PouInstance (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: PouInstance (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_add_data<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::AddDataType>,
                fallback : & mut Option < ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: AddData (None)) ;
                    * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: Documentation (None) ;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_add_data(data)?;
                        * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: Documentation (None) ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: AddData (Some (deserializer))) ;
                                * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: Documentation (None) ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: AddData (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
            fn handle_documentation<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, super::FormattedTextType>,
                fallback : & mut Option < ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState >,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: Documentation (None)) ;
                    * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: Done__ ;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_documentation(data)?;
                        * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: Done__ ;
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback . get_or_insert (ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: Documentation (Some (deserializer))) ;
                                * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: Done__ ;
                            }
                            ElementHandlerOutput::Break { .. } => {
                                * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: Documentation (Some (deserializer)) ;
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de>
            Deserializer<
                'de,
                super::ProjectInstancesConfigurationsConfigurationResourceTaskElementType,
            >
            for Box<ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializer>
        {
            fn init<R>(
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<
                'de,
                super::ProjectInstancesConfigurationsConfigurationResourceTaskElementType,
            >
            where
                R: DeserializeReader,
            {
                reader . init_deserializer_from_start_event (event , ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializer :: from_bytes_start)
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<
                'de,
                super::ProjectInstancesConfigurationsConfigurationResourceTaskElementType,
            >
            where
                R: DeserializeReader,
            {
                use ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::PouInstance(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_pou_instance(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: PouInstance (None) ;
                            event
                        }
                        (S::PouInstance(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"pouInstance",
                                true,
                            )?;
                            match self.handle_pou_instance(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::AddData(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"addData",
                                true,
                            )?;
                            match self.handle_add_data(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Documentation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            let output = reader.init_start_tag_deserializer(
                                event,
                                Some(&super::super::NS_PPX),
                                b"documentation",
                                true,
                            )?;
                            match self.handle_documentation(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (S::Done__, event) => {
                            fallback.get_or_insert(S::Done__);
                            break (DeserializerEvent::Continue(event), allow_any_element);
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(
                mut self,
                reader: &R,
            ) -> Result<
                super::ProjectInstancesConfigurationsConfigurationResourceTaskElementType,
                Error,
            >
            where
                R: DeserializeReader,
            {
                let state = replace (& mut * self . state , ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeDeserializerState :: Unknown__) ;
                self.finish_state(reader, state)?;
                Ok(
                    super::ProjectInstancesConfigurationsConfigurationResourceTaskElementType {
                        name: self.name,
                        single: self.single,
                        interval: self.interval,
                        priority: self.priority,
                        global_id: self.global_id,
                        pou_instance: self.pou_instance,
                        add_data: self.add_data,
                        documentation: self.documentation,
                    },
                )
            }
        }
    }
    pub mod quick_xml_serialize {
        use core::iter::Iterator;
        use xsd_parser::{
            quick_xml::{
                write_attrib, write_attrib_opt, BytesEnd, BytesStart, Error, Event, IterSerializer,
                WithSerializer,
            },
            xml::AnyElement,
        };
        #[derive(Debug)]
        pub struct AddDataTypeSerializer<'ser> {
            pub(super) value: &'ser super::AddDataType,
            pub(super) state: Box<AddDataTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum AddDataTypeSerializerState<'ser> {
            Init__,
            Data(
                IterSerializer<
                    'ser,
                    &'ser [super::AddDataDataElementType],
                    super::AddDataDataElementType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> AddDataTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        AddDataTypeSerializerState::Init__ => {
                            *self.state = AddDataTypeSerializerState::Data(IterSerializer::new(
                                &self.value.data[..],
                                Some("data"),
                                false,
                            ));
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        AddDataTypeSerializerState::Data(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = AddDataTypeSerializerState::End__,
                        },
                        AddDataTypeSerializerState::End__ => {
                            *self.state = AddDataTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        AddDataTypeSerializerState::Done__ => return Ok(None),
                        AddDataTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for AddDataTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = AddDataTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct AddDataInfoTypeSerializer<'ser> {
            pub(super) value: &'ser super::AddDataInfoType,
            pub(super) state: Box<AddDataInfoTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum AddDataInfoTypeSerializerState<'ser> {
            Init__,
            Info(
                IterSerializer<
                    'ser,
                    &'ser [super::AddDataInfoInfoElementType],
                    super::AddDataInfoInfoElementType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> AddDataInfoTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        AddDataInfoTypeSerializerState::Init__ => {
                            *self.state = AddDataInfoTypeSerializerState::Info(
                                IterSerializer::new(&self.value.info[..], Some("info"), false),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        AddDataInfoTypeSerializerState::Info(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = AddDataInfoTypeSerializerState::End__,
                        },
                        AddDataInfoTypeSerializerState::End__ => {
                            *self.state = AddDataInfoTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        AddDataInfoTypeSerializerState::Done__ => return Ok(None),
                        AddDataInfoTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for AddDataInfoTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = AddDataInfoTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct BodyTypeSerializer<'ser> {
            pub(super) value: &'ser super::BodyType,
            pub(super) state: Box<BodyTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum BodyTypeSerializerState<'ser> {
            Init__,
            Content__(IterSerializer<'ser, &'ser [super::BodyTypeContent], super::BodyTypeContent>),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> BodyTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        BodyTypeSerializerState::Init__ => {
                            *self.state = BodyTypeSerializerState::Content__(IterSerializer::new(
                                &self.value.content[..],
                                None,
                                false,
                            ));
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib_opt(
                                &mut bytes,
                                "WorksheetName",
                                &self.value.worksheet_name,
                            )?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        BodyTypeSerializerState::Content__(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = BodyTypeSerializerState::End__,
                        },
                        BodyTypeSerializerState::End__ => {
                            *self.state = BodyTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        BodyTypeSerializerState::Done__ => return Ok(None),
                        BodyTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for BodyTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = BodyTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct BodyTypeContentSerializer<'ser> {
            pub(super) value: &'ser super::BodyTypeContent,
            pub(super) state: Box<BodyTypeContentSerializerState<'ser>>,
        }
        #[derive(Debug)]
        pub(super) enum BodyTypeContentSerializerState<'ser> {
            Init__,
            Il(<super::FormattedTextType as WithSerializer>::Serializer<'ser>),
            St(<super::FormattedTextType as WithSerializer>::Serializer<'ser>),
            Fbd(<super::BodyFbdElementType as WithSerializer>::Serializer<'ser>),
            Ld(<super::BodyLdElementType as WithSerializer>::Serializer<'ser>),
            Sfc(<super::BodySfcElementType as WithSerializer>::Serializer<'ser>),
            AddData(<super::AddDataType as WithSerializer>::Serializer<'ser>),
            Documentation(<super::FormattedTextType as WithSerializer>::Serializer<'ser>),
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> BodyTypeContentSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        BodyTypeContentSerializerState::Init__ => match self.value {
                            super::BodyTypeContent::Il(x) => {
                                *self.state = BodyTypeContentSerializerState::Il(
                                    WithSerializer::serializer(x, Some("IL"), false)?,
                                )
                            }
                            super::BodyTypeContent::St(x) => {
                                *self.state = BodyTypeContentSerializerState::St(
                                    WithSerializer::serializer(x, Some("ST"), false)?,
                                )
                            }
                            super::BodyTypeContent::Fbd(x) => {
                                *self.state = BodyTypeContentSerializerState::Fbd(
                                    WithSerializer::serializer(x, Some("FBD"), false)?,
                                )
                            }
                            super::BodyTypeContent::Ld(x) => {
                                *self.state = BodyTypeContentSerializerState::Ld(
                                    WithSerializer::serializer(x, Some("LD"), false)?,
                                )
                            }
                            super::BodyTypeContent::Sfc(x) => {
                                *self.state = BodyTypeContentSerializerState::Sfc(
                                    WithSerializer::serializer(x, Some("SFC"), false)?,
                                )
                            }
                            super::BodyTypeContent::AddData(x) => {
                                *self.state = BodyTypeContentSerializerState::AddData(
                                    WithSerializer::serializer(x, Some("addData"), false)?,
                                )
                            }
                            super::BodyTypeContent::Documentation(x) => {
                                *self.state = BodyTypeContentSerializerState::Documentation(
                                    WithSerializer::serializer(x, Some("documentation"), false)?,
                                )
                            }
                        },
                        BodyTypeContentSerializerState::Il(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = BodyTypeContentSerializerState::Done__,
                        },
                        BodyTypeContentSerializerState::St(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = BodyTypeContentSerializerState::Done__,
                        },
                        BodyTypeContentSerializerState::Fbd(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = BodyTypeContentSerializerState::Done__,
                        },
                        BodyTypeContentSerializerState::Ld(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = BodyTypeContentSerializerState::Done__,
                        },
                        BodyTypeContentSerializerState::Sfc(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = BodyTypeContentSerializerState::Done__,
                        },
                        BodyTypeContentSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = BodyTypeContentSerializerState::Done__,
                            }
                        }
                        BodyTypeContentSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = BodyTypeContentSerializerState::Done__,
                            }
                        }
                        BodyTypeContentSerializerState::Done__ => return Ok(None),
                        BodyTypeContentSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for BodyTypeContentSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = BodyTypeContentSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ConnectionTypeSerializer<'ser> {
            pub(super) value: &'ser super::ConnectionType,
            pub(super) state: Box<ConnectionTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ConnectionTypeSerializerState<'ser> {
            Init__,
            Position(IterSerializer<'ser, &'ser [super::PositionType], super::PositionType>),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ConnectionTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ConnectionTypeSerializerState::Init__ => {
                            *self.state =
                                ConnectionTypeSerializerState::Position(IterSerializer::new(
                                    &self.value.position[..],
                                    Some("position"),
                                    false,
                                ));
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            write_attrib(&mut bytes, "refLocalId", &self.value.ref_local_id)?;
                            write_attrib_opt(
                                &mut bytes,
                                "formalParameter",
                                &self.value.formal_parameter,
                            )?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ConnectionTypeSerializerState::Position(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ConnectionTypeSerializerState::AddData(IterSerializer::new(
                                        self.value.add_data.as_ref(),
                                        Some("addData"),
                                        false,
                                    ))
                            }
                        },
                        ConnectionTypeSerializerState::AddData(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = ConnectionTypeSerializerState::End__,
                        },
                        ConnectionTypeSerializerState::End__ => {
                            *self.state = ConnectionTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ConnectionTypeSerializerState::Done__ => return Ok(None),
                        ConnectionTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ConnectionTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ConnectionTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ConnectionPointInTypeSerializer<'ser> {
            pub(super) value: &'ser super::ConnectionPointInType,
            pub(super) state: Box<ConnectionPointInTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ConnectionPointInTypeSerializerState<'ser> {
            Init__,
            Content__(
                IterSerializer<
                    'ser,
                    &'ser [super::ConnectionPointInTypeContent],
                    super::ConnectionPointInTypeContent,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ConnectionPointInTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ConnectionPointInTypeSerializerState::Init__ => {
                            *self.state = ConnectionPointInTypeSerializerState::Content__(
                                IterSerializer::new(&self.value.content[..], None, false),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ConnectionPointInTypeSerializerState::Content__(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = ConnectionPointInTypeSerializerState::End__,
                            }
                        }
                        ConnectionPointInTypeSerializerState::End__ => {
                            *self.state = ConnectionPointInTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ConnectionPointInTypeSerializerState::Done__ => return Ok(None),
                        ConnectionPointInTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ConnectionPointInTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ConnectionPointInTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ConnectionPointInTypeContentSerializer<'ser> {
            pub(super) value: &'ser super::ConnectionPointInTypeContent,
            pub(super) state: Box<ConnectionPointInTypeContentSerializerState<'ser>>,
        }
        #[derive(Debug)]
        pub(super) enum ConnectionPointInTypeContentSerializerState<'ser> {
            Init__,
            RelPosition(<super::PositionType as WithSerializer>::Serializer<'ser>),
            Connection(<super::ConnectionType as WithSerializer>::Serializer<'ser>),
            Expression(<::std::string::String as WithSerializer>::Serializer<'ser>),
            AddData(<super::AddDataType as WithSerializer>::Serializer<'ser>),
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ConnectionPointInTypeContentSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ConnectionPointInTypeContentSerializerState::Init__ => match self.value {
                            super::ConnectionPointInTypeContent::RelPosition(x) => {
                                *self.state =
                                    ConnectionPointInTypeContentSerializerState::RelPosition(
                                        WithSerializer::serializer(x, Some("relPosition"), false)?,
                                    )
                            }
                            super::ConnectionPointInTypeContent::Connection(x) => {
                                *self.state =
                                    ConnectionPointInTypeContentSerializerState::Connection(
                                        WithSerializer::serializer(x, Some("connection"), false)?,
                                    )
                            }
                            super::ConnectionPointInTypeContent::Expression(x) => {
                                *self.state =
                                    ConnectionPointInTypeContentSerializerState::Expression(
                                        WithSerializer::serializer(x, Some("expression"), false)?,
                                    )
                            }
                            super::ConnectionPointInTypeContent::AddData(x) => {
                                *self.state = ConnectionPointInTypeContentSerializerState::AddData(
                                    WithSerializer::serializer(x, Some("addData"), false)?,
                                )
                            }
                        },
                        ConnectionPointInTypeContentSerializerState::RelPosition(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ConnectionPointInTypeContentSerializerState::Done__
                                }
                            }
                        }
                        ConnectionPointInTypeContentSerializerState::Connection(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ConnectionPointInTypeContentSerializerState::Done__
                                }
                            }
                        }
                        ConnectionPointInTypeContentSerializerState::Expression(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ConnectionPointInTypeContentSerializerState::Done__
                                }
                            }
                        }
                        ConnectionPointInTypeContentSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ConnectionPointInTypeContentSerializerState::Done__
                                }
                            }
                        }
                        ConnectionPointInTypeContentSerializerState::Done__ => return Ok(None),
                        ConnectionPointInTypeContentSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ConnectionPointInTypeContentSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ConnectionPointInTypeContentSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ConnectionPointOutTypeSerializer<'ser> {
            pub(super) value: &'ser super::ConnectionPointOutType,
            pub(super) state: Box<ConnectionPointOutTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ConnectionPointOutTypeSerializerState<'ser> {
            Init__,
            RelPosition(
                IterSerializer<'ser, Option<&'ser super::PositionType>, super::PositionType>,
            ),
            Expression(
                IterSerializer<'ser, Option<&'ser ::std::string::String>, ::std::string::String>,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ConnectionPointOutTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ConnectionPointOutTypeSerializerState::Init__ => {
                            *self.state = ConnectionPointOutTypeSerializerState::RelPosition(
                                IterSerializer::new(
                                    self.value.rel_position.as_ref(),
                                    Some("relPosition"),
                                    false,
                                ),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ConnectionPointOutTypeSerializerState::RelPosition(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = ConnectionPointOutTypeSerializerState::Expression(
                                        IterSerializer::new(
                                            self.value.expression.as_ref(),
                                            Some("expression"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        ConnectionPointOutTypeSerializerState::Expression(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = ConnectionPointOutTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        ConnectionPointOutTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = ConnectionPointOutTypeSerializerState::End__,
                            }
                        }
                        ConnectionPointOutTypeSerializerState::End__ => {
                            *self.state = ConnectionPointOutTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ConnectionPointOutTypeSerializerState::Done__ => return Ok(None),
                        ConnectionPointOutTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ConnectionPointOutTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ConnectionPointOutTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct DataTypeSerializer<'ser> {
            pub(super) value: &'ser super::DataType,
            pub(super) state: Box<DataTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum DataTypeSerializerState<'ser> {
            Init__,
            Bool(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Byte(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Word(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Dword(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Lword(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Sint(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Int(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Dint(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Lint(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Usint(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Uint(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Udint(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Ulint(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Real(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Lreal(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Time(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Date(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Dt(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Tod(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            String(<super::StringElementType as WithSerializer>::Serializer<'ser>),
            Wstring(<super::StringElementType as WithSerializer>::Serializer<'ser>),
            Any(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            AnyDerived(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            AnyElementary(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            AnyMagnitude(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            AnyNum(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            AnyReal(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            AnyInt(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            AnyBit(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            AnyString(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            AnyDate(<super::super::xs::AnyType as WithSerializer>::Serializer<'ser>),
            Array(<super::ArrayElementType as WithSerializer>::Serializer<'ser>),
            Derived(<super::DerivedElementType as WithSerializer>::Serializer<'ser>),
            Enum(<super::EnumElementType as WithSerializer>::Serializer<'ser>),
            Struct(<super::VarListPlainType as WithSerializer>::Serializer<'ser>),
            SubrangeSigned(<super::SubrangeSignedElementType as WithSerializer>::Serializer<'ser>),
            SubrangeUnsigned(
                <super::SubrangeSignedElementType as WithSerializer>::Serializer<'ser>,
            ),
            Pointer(<super::PointerElementType as WithSerializer>::Serializer<'ser>),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> DataTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        DataTypeSerializerState::Init__ => {
                            match self.value {
                                super::DataType::Bool(x) => {
                                    *self.state = DataTypeSerializerState::Bool(
                                        WithSerializer::serializer(x, Some("BOOL"), self.is_root)?,
                                    )
                                }
                                super::DataType::Byte(x) => {
                                    *self.state = DataTypeSerializerState::Byte(
                                        WithSerializer::serializer(x, Some("BYTE"), self.is_root)?,
                                    )
                                }
                                super::DataType::Word(x) => {
                                    *self.state = DataTypeSerializerState::Word(
                                        WithSerializer::serializer(x, Some("WORD"), self.is_root)?,
                                    )
                                }
                                super::DataType::Dword(x) => {
                                    *self.state = DataTypeSerializerState::Dword(
                                        WithSerializer::serializer(x, Some("DWORD"), self.is_root)?,
                                    )
                                }
                                super::DataType::Lword(x) => {
                                    *self.state = DataTypeSerializerState::Lword(
                                        WithSerializer::serializer(x, Some("LWORD"), self.is_root)?,
                                    )
                                }
                                super::DataType::Sint(x) => {
                                    *self.state = DataTypeSerializerState::Sint(
                                        WithSerializer::serializer(x, Some("SINT"), self.is_root)?,
                                    )
                                }
                                super::DataType::Int(x) => {
                                    *self.state = DataTypeSerializerState::Int(
                                        WithSerializer::serializer(x, Some("INT"), self.is_root)?,
                                    )
                                }
                                super::DataType::Dint(x) => {
                                    *self.state = DataTypeSerializerState::Dint(
                                        WithSerializer::serializer(x, Some("DINT"), self.is_root)?,
                                    )
                                }
                                super::DataType::Lint(x) => {
                                    *self.state = DataTypeSerializerState::Lint(
                                        WithSerializer::serializer(x, Some("LINT"), self.is_root)?,
                                    )
                                }
                                super::DataType::Usint(x) => {
                                    *self.state = DataTypeSerializerState::Usint(
                                        WithSerializer::serializer(x, Some("USINT"), self.is_root)?,
                                    )
                                }
                                super::DataType::Uint(x) => {
                                    *self.state = DataTypeSerializerState::Uint(
                                        WithSerializer::serializer(x, Some("UINT"), self.is_root)?,
                                    )
                                }
                                super::DataType::Udint(x) => {
                                    *self.state = DataTypeSerializerState::Udint(
                                        WithSerializer::serializer(x, Some("UDINT"), self.is_root)?,
                                    )
                                }
                                super::DataType::Ulint(x) => {
                                    *self.state = DataTypeSerializerState::Ulint(
                                        WithSerializer::serializer(x, Some("ULINT"), self.is_root)?,
                                    )
                                }
                                super::DataType::Real(x) => {
                                    *self.state = DataTypeSerializerState::Real(
                                        WithSerializer::serializer(x, Some("REAL"), self.is_root)?,
                                    )
                                }
                                super::DataType::Lreal(x) => {
                                    *self.state = DataTypeSerializerState::Lreal(
                                        WithSerializer::serializer(x, Some("LREAL"), self.is_root)?,
                                    )
                                }
                                super::DataType::Time(x) => {
                                    *self.state = DataTypeSerializerState::Time(
                                        WithSerializer::serializer(x, Some("TIME"), self.is_root)?,
                                    )
                                }
                                super::DataType::Date(x) => {
                                    *self.state = DataTypeSerializerState::Date(
                                        WithSerializer::serializer(x, Some("DATE"), self.is_root)?,
                                    )
                                }
                                super::DataType::Dt(x) => {
                                    *self.state = DataTypeSerializerState::Dt(
                                        WithSerializer::serializer(x, Some("DT"), self.is_root)?,
                                    )
                                }
                                super::DataType::Tod(x) => {
                                    *self.state = DataTypeSerializerState::Tod(
                                        WithSerializer::serializer(x, Some("TOD"), self.is_root)?,
                                    )
                                }
                                super::DataType::String(x) => {
                                    *self.state =
                                        DataTypeSerializerState::String(WithSerializer::serializer(
                                            x,
                                            Some("string"),
                                            self.is_root,
                                        )?)
                                }
                                super::DataType::Wstring(x) => {
                                    *self.state = DataTypeSerializerState::Wstring(
                                        WithSerializer::serializer(
                                            x,
                                            Some("wstring"),
                                            self.is_root,
                                        )?,
                                    )
                                }
                                super::DataType::Any(x) => {
                                    *self.state = DataTypeSerializerState::Any(
                                        WithSerializer::serializer(x, Some("ANY"), self.is_root)?,
                                    )
                                }
                                super::DataType::AnyDerived(x) => {
                                    *self.state = DataTypeSerializerState::AnyDerived(
                                        WithSerializer::serializer(
                                            x,
                                            Some("ANY_DERIVED"),
                                            self.is_root,
                                        )?,
                                    )
                                }
                                super::DataType::AnyElementary(x) => {
                                    *self.state = DataTypeSerializerState::AnyElementary(
                                        WithSerializer::serializer(
                                            x,
                                            Some("ANY_ELEMENTARY"),
                                            self.is_root,
                                        )?,
                                    )
                                }
                                super::DataType::AnyMagnitude(x) => {
                                    *self.state = DataTypeSerializerState::AnyMagnitude(
                                        WithSerializer::serializer(
                                            x,
                                            Some("ANY_MAGNITUDE"),
                                            self.is_root,
                                        )?,
                                    )
                                }
                                super::DataType::AnyNum(x) => {
                                    *self.state =
                                        DataTypeSerializerState::AnyNum(WithSerializer::serializer(
                                            x,
                                            Some("ANY_NUM"),
                                            self.is_root,
                                        )?)
                                }
                                super::DataType::AnyReal(x) => {
                                    *self.state = DataTypeSerializerState::AnyReal(
                                        WithSerializer::serializer(
                                            x,
                                            Some("ANY_REAL"),
                                            self.is_root,
                                        )?,
                                    )
                                }
                                super::DataType::AnyInt(x) => {
                                    *self.state =
                                        DataTypeSerializerState::AnyInt(WithSerializer::serializer(
                                            x,
                                            Some("ANY_INT"),
                                            self.is_root,
                                        )?)
                                }
                                super::DataType::AnyBit(x) => {
                                    *self.state =
                                        DataTypeSerializerState::AnyBit(WithSerializer::serializer(
                                            x,
                                            Some("ANY_BIT"),
                                            self.is_root,
                                        )?)
                                }
                                super::DataType::AnyString(x) => {
                                    *self.state = DataTypeSerializerState::AnyString(
                                        WithSerializer::serializer(
                                            x,
                                            Some("ANY_STRING"),
                                            self.is_root,
                                        )?,
                                    )
                                }
                                super::DataType::AnyDate(x) => {
                                    *self.state = DataTypeSerializerState::AnyDate(
                                        WithSerializer::serializer(
                                            x,
                                            Some("ANY_DATE"),
                                            self.is_root,
                                        )?,
                                    )
                                }
                                super::DataType::Array(x) => {
                                    *self.state =
                                        DataTypeSerializerState::Array(WithSerializer::serializer(
                                            &**x,
                                            Some("array"),
                                            self.is_root,
                                        )?)
                                }
                                super::DataType::Derived(x) => {
                                    *self.state = DataTypeSerializerState::Derived(
                                        WithSerializer::serializer(
                                            x,
                                            Some("derived"),
                                            self.is_root,
                                        )?,
                                    )
                                }
                                super::DataType::Enum(x) => {
                                    *self.state =
                                        DataTypeSerializerState::Enum(WithSerializer::serializer(
                                            &**x,
                                            Some("enum"),
                                            self.is_root,
                                        )?)
                                }
                                super::DataType::Struct(x) => {
                                    *self.state =
                                        DataTypeSerializerState::Struct(WithSerializer::serializer(
                                            x,
                                            Some("struct"),
                                            self.is_root,
                                        )?)
                                }
                                super::DataType::SubrangeSigned(x) => {
                                    *self.state = DataTypeSerializerState::SubrangeSigned(
                                        WithSerializer::serializer(
                                            &**x,
                                            Some("subrangeSigned"),
                                            self.is_root,
                                        )?,
                                    )
                                }
                                super::DataType::SubrangeUnsigned(x) => {
                                    *self.state = DataTypeSerializerState::SubrangeUnsigned(
                                        WithSerializer::serializer(
                                            &**x,
                                            Some("subrangeUnsigned"),
                                            self.is_root,
                                        )?,
                                    )
                                }
                                super::DataType::Pointer(x) => {
                                    *self.state = DataTypeSerializerState::Pointer(
                                        WithSerializer::serializer(
                                            &**x,
                                            Some("pointer"),
                                            self.is_root,
                                        )?,
                                    )
                                }
                            }
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        DataTypeSerializerState::Bool(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Byte(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Word(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Dword(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Lword(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Sint(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Int(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Dint(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Lint(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Usint(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Uint(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Udint(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Ulint(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Real(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Lreal(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Time(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Date(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Dt(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Tod(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::String(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Wstring(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Any(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::AnyDerived(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::AnyElementary(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::AnyMagnitude(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::AnyNum(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::AnyReal(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::AnyInt(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::AnyBit(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::AnyString(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::AnyDate(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Array(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Derived(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Enum(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::Struct(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::SubrangeSigned(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = DataTypeSerializerState::End__,
                            }
                        }
                        DataTypeSerializerState::SubrangeUnsigned(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = DataTypeSerializerState::End__,
                            }
                        }
                        DataTypeSerializerState::Pointer(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = DataTypeSerializerState::End__,
                        },
                        DataTypeSerializerState::End__ => {
                            *self.state = DataTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        DataTypeSerializerState::Done__ => return Ok(None),
                        DataTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for DataTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = DataTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct FormattedTextTypeSerializer<'ser> {
            pub(super) value: &'ser super::FormattedTextType,
            pub(super) state: Box<FormattedTextTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum FormattedTextTypeSerializerState<'ser> {
            Init__,
            Any(<AnyElement as WithSerializer>::Serializer<'ser>),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> FormattedTextTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        FormattedTextTypeSerializerState::Init__ => {
                            *self.state = FormattedTextTypeSerializerState::Any(
                                WithSerializer::serializer(&self.value.any, Some("any16"), false)?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        FormattedTextTypeSerializerState::Any(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = FormattedTextTypeSerializerState::End__,
                        },
                        FormattedTextTypeSerializerState::End__ => {
                            *self.state = FormattedTextTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        FormattedTextTypeSerializerState::Done__ => return Ok(None),
                        FormattedTextTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for FormattedTextTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = FormattedTextTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct PositionTypeSerializer<'ser> {
            pub(super) value: &'ser super::PositionType,
            pub(super) state: Box<PositionTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum PositionTypeSerializerState<'ser> {
            Init__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> PositionTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        PositionTypeSerializerState::Init__ => {
                            *self.state = PositionTypeSerializerState::Done__;
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "x", &self.value.x)?;
                            write_attrib(&mut bytes, "y", &self.value.y)?;
                            return Ok(Some(Event::Empty(bytes)));
                        }
                        PositionTypeSerializerState::Done__ => return Ok(None),
                        PositionTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for PositionTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = PositionTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct PouInstanceTypeSerializer<'ser> {
            pub(super) value: &'ser super::PouInstanceType,
            pub(super) state: Box<PouInstanceTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum PouInstanceTypeSerializerState<'ser> {
            Init__,
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> PouInstanceTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        PouInstanceTypeSerializerState::Init__ => {
                            *self.state =
                                PouInstanceTypeSerializerState::AddData(IterSerializer::new(
                                    self.value.add_data.as_ref(),
                                    Some("addData"),
                                    false,
                                ));
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "name", &self.value.name)?;
                            write_attrib(&mut bytes, "typeName", &self.value.type_name)?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        PouInstanceTypeSerializerState::AddData(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = PouInstanceTypeSerializerState::Documentation(
                                    IterSerializer::new(
                                        self.value.documentation.as_ref(),
                                        Some("documentation"),
                                        false,
                                    ),
                                )
                            }
                        },
                        PouInstanceTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = PouInstanceTypeSerializerState::End__,
                            }
                        }
                        PouInstanceTypeSerializerState::End__ => {
                            *self.state = PouInstanceTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        PouInstanceTypeSerializerState::Done__ => return Ok(None),
                        PouInstanceTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for PouInstanceTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = PouInstanceTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectElementType,
            pub(super) state: Box<ProjectElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectElementTypeSerializerState<'ser> {
            Init__,
            FileHeader(<super::ProjectFileHeaderElementType as WithSerializer>::Serializer<'ser>),
            ContentHeader(
                <super::ProjectContentHeaderElementType as WithSerializer>::Serializer<'ser>,
            ),
            Types(<super::ProjectTypesElementType as WithSerializer>::Serializer<'ser>),
            Instances(<super::ProjectInstancesElementType as WithSerializer>::Serializer<'ser>),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ProjectElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ProjectElementTypeSerializerState::Init__ => {
                            *self.state = ProjectElementTypeSerializerState::FileHeader(
                                WithSerializer::serializer(
                                    &self.value.file_header,
                                    Some("fileHeader"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ProjectElementTypeSerializerState::FileHeader(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = ProjectElementTypeSerializerState::ContentHeader(
                                        WithSerializer::serializer(
                                            &self.value.content_header,
                                            Some("contentHeader"),
                                            false,
                                        )?,
                                    )
                                }
                            }
                        }
                        ProjectElementTypeSerializerState::ContentHeader(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = ProjectElementTypeSerializerState::Types(
                                        WithSerializer::serializer(
                                            &self.value.types,
                                            Some("types"),
                                            false,
                                        )?,
                                    )
                                }
                            }
                        }
                        ProjectElementTypeSerializerState::Types(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = ProjectElementTypeSerializerState::Instances(
                                        WithSerializer::serializer(
                                            &self.value.instances,
                                            Some("instances"),
                                            false,
                                        )?,
                                    )
                                }
                            }
                        }
                        ProjectElementTypeSerializerState::Instances(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = ProjectElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        ProjectElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = ProjectElementTypeSerializerState::Documentation(
                                        IterSerializer::new(
                                            self.value.documentation.as_ref(),
                                            Some("documentation"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        ProjectElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = ProjectElementTypeSerializerState::End__,
                            }
                        }
                        ProjectElementTypeSerializerState::End__ => {
                            *self.state = ProjectElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ProjectElementTypeSerializerState::Done__ => return Ok(None),
                        ProjectElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ProjectElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ProjectElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct RangeSignedTypeSerializer<'ser> {
            pub(super) value: &'ser super::RangeSignedType,
            pub(super) state: Box<RangeSignedTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum RangeSignedTypeSerializerState<'ser> {
            Init__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> RangeSignedTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        RangeSignedTypeSerializerState::Init__ => {
                            *self.state = RangeSignedTypeSerializerState::Done__;
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "lower", &self.value.lower)?;
                            write_attrib(&mut bytes, "upper", &self.value.upper)?;
                            return Ok(Some(Event::Empty(bytes)));
                        }
                        RangeSignedTypeSerializerState::Done__ => return Ok(None),
                        RangeSignedTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for RangeSignedTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = RangeSignedTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ValueTypeSerializer<'ser> {
            pub(super) value: &'ser super::ValueType,
            pub(super) state: Box<ValueTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ValueTypeSerializerState<'ser> {
            Init__,
            SimpleValue(<super::ValueSimpleValueElementType as WithSerializer>::Serializer<'ser>),
            ArrayValue(<super::ValueArrayValueElementType as WithSerializer>::Serializer<'ser>),
            StructValue(<super::ValueStructValueElementType as WithSerializer>::Serializer<'ser>),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ValueTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ValueTypeSerializerState::Init__ => {
                            match self.value {
                                super::ValueType::SimpleValue(x) => {
                                    *self.state = ValueTypeSerializerState::SimpleValue(
                                        WithSerializer::serializer(
                                            x,
                                            Some("simpleValue"),
                                            self.is_root,
                                        )?,
                                    )
                                }
                                super::ValueType::ArrayValue(x) => {
                                    *self.state = ValueTypeSerializerState::ArrayValue(
                                        WithSerializer::serializer(
                                            x,
                                            Some("arrayValue"),
                                            self.is_root,
                                        )?,
                                    )
                                }
                                super::ValueType::StructValue(x) => {
                                    *self.state = ValueTypeSerializerState::StructValue(
                                        WithSerializer::serializer(
                                            x,
                                            Some("structValue"),
                                            self.is_root,
                                        )?,
                                    )
                                }
                            }
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ValueTypeSerializerState::SimpleValue(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = ValueTypeSerializerState::End__,
                        },
                        ValueTypeSerializerState::ArrayValue(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = ValueTypeSerializerState::End__,
                        },
                        ValueTypeSerializerState::StructValue(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = ValueTypeSerializerState::End__,
                        },
                        ValueTypeSerializerState::End__ => {
                            *self.state = ValueTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ValueTypeSerializerState::Done__ => return Ok(None),
                        ValueTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ValueTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ValueTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct VarListTypeSerializer<'ser> {
            pub(super) value: &'ser super::VarListType,
            pub(super) state: Box<VarListTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum VarListTypeSerializerState<'ser> {
            Init__,
            Variable(
                IterSerializer<
                    'ser,
                    &'ser [super::VarListPlainVariableElementType],
                    super::VarListPlainVariableElementType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> VarListTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        VarListTypeSerializerState::Init__ => {
                            *self.state =
                                VarListTypeSerializerState::Variable(IterSerializer::new(
                                    &self.value.variable[..],
                                    Some("variable"),
                                    false,
                                ));
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib_opt(&mut bytes, "name", &self.value.name)?;
                            write_attrib(&mut bytes, "constant", &self.value.constant)?;
                            write_attrib(&mut bytes, "retain", &self.value.retain)?;
                            write_attrib(&mut bytes, "nonretain", &self.value.nonretain)?;
                            write_attrib(&mut bytes, "persistent", &self.value.persistent)?;
                            write_attrib(&mut bytes, "nonpersistent", &self.value.nonpersistent)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        VarListTypeSerializerState::Variable(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    VarListTypeSerializerState::AddData(IterSerializer::new(
                                        self.value.add_data.as_ref(),
                                        Some("addData"),
                                        false,
                                    ))
                            }
                        },
                        VarListTypeSerializerState::AddData(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    VarListTypeSerializerState::Documentation(IterSerializer::new(
                                        self.value.documentation.as_ref(),
                                        Some("documentation"),
                                        false,
                                    ))
                            }
                        },
                        VarListTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = VarListTypeSerializerState::End__,
                            }
                        }
                        VarListTypeSerializerState::End__ => {
                            *self.state = VarListTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        VarListTypeSerializerState::Done__ => return Ok(None),
                        VarListTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for VarListTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = VarListTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct VarListAccessTypeSerializer<'ser> {
            pub(super) value: &'ser super::VarListAccessType,
            pub(super) state: Box<VarListAccessTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum VarListAccessTypeSerializerState<'ser> {
            Init__,
            AccessVariable(
                IterSerializer<
                    'ser,
                    &'ser [super::VarListAccessAccessVariableElementType],
                    super::VarListAccessAccessVariableElementType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> VarListAccessTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        VarListAccessTypeSerializerState::Init__ => {
                            *self.state = VarListAccessTypeSerializerState::AccessVariable(
                                IterSerializer::new(
                                    &self.value.access_variable[..],
                                    Some("accessVariable"),
                                    false,
                                ),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        VarListAccessTypeSerializerState::AccessVariable(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = VarListAccessTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        VarListAccessTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = VarListAccessTypeSerializerState::Documentation(
                                        IterSerializer::new(
                                            self.value.documentation.as_ref(),
                                            Some("documentation"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        VarListAccessTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = VarListAccessTypeSerializerState::End__,
                            }
                        }
                        VarListAccessTypeSerializerState::End__ => {
                            *self.state = VarListAccessTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        VarListAccessTypeSerializerState::Done__ => return Ok(None),
                        VarListAccessTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for VarListAccessTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = VarListAccessTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct VarListConfigTypeSerializer<'ser> {
            pub(super) value: &'ser super::VarListConfigType,
            pub(super) state: Box<VarListConfigTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum VarListConfigTypeSerializerState<'ser> {
            Init__,
            ConfigVariable(
                IterSerializer<
                    'ser,
                    &'ser [super::VarListConfigConfigVariableElementType],
                    super::VarListConfigConfigVariableElementType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> VarListConfigTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        VarListConfigTypeSerializerState::Init__ => {
                            *self.state = VarListConfigTypeSerializerState::ConfigVariable(
                                IterSerializer::new(
                                    &self.value.config_variable[..],
                                    Some("configVariable"),
                                    false,
                                ),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        VarListConfigTypeSerializerState::ConfigVariable(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = VarListConfigTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        VarListConfigTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = VarListConfigTypeSerializerState::Documentation(
                                        IterSerializer::new(
                                            self.value.documentation.as_ref(),
                                            Some("documentation"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        VarListConfigTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = VarListConfigTypeSerializerState::End__,
                            }
                        }
                        VarListConfigTypeSerializerState::End__ => {
                            *self.state = VarListConfigTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        VarListConfigTypeSerializerState::Done__ => return Ok(None),
                        VarListConfigTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for VarListConfigTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = VarListConfigTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct VarListPlainTypeSerializer<'ser> {
            pub(super) value: &'ser super::VarListPlainType,
            pub(super) state: Box<VarListPlainTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum VarListPlainTypeSerializerState<'ser> {
            Init__,
            Variable(
                IterSerializer<
                    'ser,
                    &'ser [super::VarListPlainVariableElementType],
                    super::VarListPlainVariableElementType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> VarListPlainTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        VarListPlainTypeSerializerState::Init__ => {
                            *self.state =
                                VarListPlainTypeSerializerState::Variable(IterSerializer::new(
                                    &self.value.variable[..],
                                    Some("variable"),
                                    false,
                                ));
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        VarListPlainTypeSerializerState::Variable(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = VarListPlainTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        VarListPlainTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = VarListPlainTypeSerializerState::Documentation(
                                        IterSerializer::new(
                                            self.value.documentation.as_ref(),
                                            Some("documentation"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        VarListPlainTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = VarListPlainTypeSerializerState::End__,
                            }
                        }
                        VarListPlainTypeSerializerState::End__ => {
                            *self.state = VarListPlainTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        VarListPlainTypeSerializerState::Done__ => return Ok(None),
                        VarListPlainTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for VarListPlainTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = VarListPlainTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct AddDataDataElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::AddDataDataElementType,
            pub(super) state: Box<AddDataDataElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum AddDataDataElementTypeSerializerState<'ser> {
            Init__,
            Any(<AnyElement as WithSerializer>::Serializer<'ser>),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> AddDataDataElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        AddDataDataElementTypeSerializerState::Init__ => {
                            *self.state = AddDataDataElementTypeSerializerState::Any(
                                WithSerializer::serializer(&self.value.any, Some("any37"), false)?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "name", &self.value.name)?;
                            write_attrib(&mut bytes, "handleUnknown", &self.value.handle_unknown)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        AddDataDataElementTypeSerializerState::Any(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = AddDataDataElementTypeSerializerState::End__,
                            }
                        }
                        AddDataDataElementTypeSerializerState::End__ => {
                            *self.state = AddDataDataElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        AddDataDataElementTypeSerializerState::Done__ => return Ok(None),
                        AddDataDataElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for AddDataDataElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = AddDataDataElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct AddDataInfoInfoElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::AddDataInfoInfoElementType,
            pub(super) state: Box<AddDataInfoInfoElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum AddDataInfoInfoElementTypeSerializerState<'ser> {
            Init__,
            Description(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> AddDataInfoInfoElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        AddDataInfoInfoElementTypeSerializerState::Init__ => {
                            *self.state = AddDataInfoInfoElementTypeSerializerState::Description(
                                IterSerializer::new(
                                    self.value.description.as_ref(),
                                    Some("description"),
                                    false,
                                ),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "name", &self.value.name)?;
                            write_attrib_opt(&mut bytes, "version", &self.value.version)?;
                            write_attrib(&mut bytes, "vendor", &self.value.vendor)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        AddDataInfoInfoElementTypeSerializerState::Description(x) => match x
                            .next()
                            .transpose()?
                        {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = AddDataInfoInfoElementTypeSerializerState::End__,
                        },
                        AddDataInfoInfoElementTypeSerializerState::End__ => {
                            *self.state = AddDataInfoInfoElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        AddDataInfoInfoElementTypeSerializerState::Done__ => return Ok(None),
                        AddDataInfoInfoElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for AddDataInfoInfoElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = AddDataInfoInfoElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct BodyFbdElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::BodyFbdElementType,
            pub(super) state: Box<BodyFbdElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum BodyFbdElementTypeSerializerState<'ser> {
            Init__,
            Content__(
                IterSerializer<
                    'ser,
                    &'ser [super::BodyFbdElementTypeContent],
                    super::BodyFbdElementTypeContent,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> BodyFbdElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        BodyFbdElementTypeSerializerState::Init__ => {
                            *self.state = BodyFbdElementTypeSerializerState::Content__(
                                IterSerializer::new(&self.value.content[..], None, false),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        BodyFbdElementTypeSerializerState::Content__(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = BodyFbdElementTypeSerializerState::End__,
                            }
                        }
                        BodyFbdElementTypeSerializerState::End__ => {
                            *self.state = BodyFbdElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        BodyFbdElementTypeSerializerState::Done__ => return Ok(None),
                        BodyFbdElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for BodyFbdElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = BodyFbdElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct BodyFbdElementTypeContentSerializer<'ser> {
            pub(super) value: &'ser super::BodyFbdElementTypeContent,
            pub(super) state: Box<BodyFbdElementTypeContentSerializerState<'ser>>,
        }
        #[derive(Debug)]
        pub(super) enum BodyFbdElementTypeContentSerializerState<'ser> {
            Init__,
            Comment(<super::CommentElementType as WithSerializer>::Serializer<'ser>),
            Error(<super::CommentElementType as WithSerializer>::Serializer<'ser>),
            Connector(<super::ConnectorElementType as WithSerializer>::Serializer<'ser>),
            Continuation(<super::ContinuationElementType as WithSerializer>::Serializer<'ser>),
            ActionBlock(<super::ActionBlockElementType as WithSerializer>::Serializer<'ser>),
            VendorElement(<super::VendorElementElementType as WithSerializer>::Serializer<'ser>),
            Block(<super::BlockElementType as WithSerializer>::Serializer<'ser>),
            InVariable(<super::InVariableElementType as WithSerializer>::Serializer<'ser>),
            OutVariable(<super::OutVariableElementType as WithSerializer>::Serializer<'ser>),
            InOutVariable(<super::InOutVariableElementType as WithSerializer>::Serializer<'ser>),
            Label(<super::LabelElementType as WithSerializer>::Serializer<'ser>),
            Jump(<super::JumpElementType as WithSerializer>::Serializer<'ser>),
            Return(<super::ReturnElementType as WithSerializer>::Serializer<'ser>),
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> BodyFbdElementTypeContentSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        BodyFbdElementTypeContentSerializerState::Init__ => match self.value {
                            super::BodyFbdElementTypeContent::Comment(x) => {
                                *self.state = BodyFbdElementTypeContentSerializerState::Comment(
                                    WithSerializer::serializer(x, Some("comment"), false)?,
                                )
                            }
                            super::BodyFbdElementTypeContent::Error(x) => {
                                *self.state = BodyFbdElementTypeContentSerializerState::Error(
                                    WithSerializer::serializer(x, Some("error"), false)?,
                                )
                            }
                            super::BodyFbdElementTypeContent::Connector(x) => {
                                *self.state = BodyFbdElementTypeContentSerializerState::Connector(
                                    WithSerializer::serializer(x, Some("connector"), false)?,
                                )
                            }
                            super::BodyFbdElementTypeContent::Continuation(x) => {
                                *self.state = BodyFbdElementTypeContentSerializerState::Continuation(
                                    WithSerializer::serializer(x, Some("continuation"), false)?,
                                )
                            }
                            super::BodyFbdElementTypeContent::ActionBlock(x) => {
                                *self.state = BodyFbdElementTypeContentSerializerState::ActionBlock(
                                    WithSerializer::serializer(x, Some("actionBlock"), false)?,
                                )
                            }
                            super::BodyFbdElementTypeContent::VendorElement(x) => {
                                *self.state =
                                    BodyFbdElementTypeContentSerializerState::VendorElement(
                                        WithSerializer::serializer(
                                            x,
                                            Some("vendorElement"),
                                            false,
                                        )?,
                                    )
                            }
                            super::BodyFbdElementTypeContent::Block(x) => {
                                *self.state = BodyFbdElementTypeContentSerializerState::Block(
                                    WithSerializer::serializer(x, Some("block"), false)?,
                                )
                            }
                            super::BodyFbdElementTypeContent::InVariable(x) => {
                                *self.state = BodyFbdElementTypeContentSerializerState::InVariable(
                                    WithSerializer::serializer(x, Some("inVariable"), false)?,
                                )
                            }
                            super::BodyFbdElementTypeContent::OutVariable(x) => {
                                *self.state = BodyFbdElementTypeContentSerializerState::OutVariable(
                                    WithSerializer::serializer(x, Some("outVariable"), false)?,
                                )
                            }
                            super::BodyFbdElementTypeContent::InOutVariable(x) => {
                                *self.state =
                                    BodyFbdElementTypeContentSerializerState::InOutVariable(
                                        WithSerializer::serializer(
                                            x,
                                            Some("inOutVariable"),
                                            false,
                                        )?,
                                    )
                            }
                            super::BodyFbdElementTypeContent::Label(x) => {
                                *self.state = BodyFbdElementTypeContentSerializerState::Label(
                                    WithSerializer::serializer(x, Some("label"), false)?,
                                )
                            }
                            super::BodyFbdElementTypeContent::Jump(x) => {
                                *self.state = BodyFbdElementTypeContentSerializerState::Jump(
                                    WithSerializer::serializer(x, Some("jump"), false)?,
                                )
                            }
                            super::BodyFbdElementTypeContent::Return(x) => {
                                *self.state = BodyFbdElementTypeContentSerializerState::Return(
                                    WithSerializer::serializer(x, Some("return"), false)?,
                                )
                            }
                        },
                        BodyFbdElementTypeContentSerializerState::Comment(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyFbdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyFbdElementTypeContentSerializerState::Error(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyFbdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyFbdElementTypeContentSerializerState::Connector(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyFbdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyFbdElementTypeContentSerializerState::Continuation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyFbdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyFbdElementTypeContentSerializerState::ActionBlock(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyFbdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyFbdElementTypeContentSerializerState::VendorElement(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyFbdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyFbdElementTypeContentSerializerState::Block(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyFbdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyFbdElementTypeContentSerializerState::InVariable(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyFbdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyFbdElementTypeContentSerializerState::OutVariable(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyFbdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyFbdElementTypeContentSerializerState::InOutVariable(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyFbdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyFbdElementTypeContentSerializerState::Label(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyFbdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyFbdElementTypeContentSerializerState::Jump(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyFbdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyFbdElementTypeContentSerializerState::Return(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyFbdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyFbdElementTypeContentSerializerState::Done__ => return Ok(None),
                        BodyFbdElementTypeContentSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for BodyFbdElementTypeContentSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = BodyFbdElementTypeContentSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct BodyLdElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::BodyLdElementType,
            pub(super) state: Box<BodyLdElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum BodyLdElementTypeSerializerState<'ser> {
            Init__,
            Content__(
                IterSerializer<
                    'ser,
                    &'ser [super::BodyLdElementTypeContent],
                    super::BodyLdElementTypeContent,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> BodyLdElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        BodyLdElementTypeSerializerState::Init__ => {
                            *self.state = BodyLdElementTypeSerializerState::Content__(
                                IterSerializer::new(&self.value.content[..], None, false),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        BodyLdElementTypeSerializerState::Content__(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = BodyLdElementTypeSerializerState::End__,
                            }
                        }
                        BodyLdElementTypeSerializerState::End__ => {
                            *self.state = BodyLdElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        BodyLdElementTypeSerializerState::Done__ => return Ok(None),
                        BodyLdElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for BodyLdElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = BodyLdElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct BodyLdElementTypeContentSerializer<'ser> {
            pub(super) value: &'ser super::BodyLdElementTypeContent,
            pub(super) state: Box<BodyLdElementTypeContentSerializerState<'ser>>,
        }
        #[derive(Debug)]
        pub(super) enum BodyLdElementTypeContentSerializerState<'ser> {
            Init__,
            Comment(<super::CommentElementType as WithSerializer>::Serializer<'ser>),
            Error(<super::CommentElementType as WithSerializer>::Serializer<'ser>),
            Connector(<super::ConnectorElementType as WithSerializer>::Serializer<'ser>),
            Continuation(<super::ContinuationElementType as WithSerializer>::Serializer<'ser>),
            ActionBlock(<super::ActionBlockElementType as WithSerializer>::Serializer<'ser>),
            VendorElement(<super::VendorElementElementType as WithSerializer>::Serializer<'ser>),
            Block(<super::BlockElementType as WithSerializer>::Serializer<'ser>),
            InVariable(<super::InVariableElementType as WithSerializer>::Serializer<'ser>),
            OutVariable(<super::OutVariableElementType as WithSerializer>::Serializer<'ser>),
            InOutVariable(<super::InOutVariableElementType as WithSerializer>::Serializer<'ser>),
            Label(<super::LabelElementType as WithSerializer>::Serializer<'ser>),
            Jump(<super::JumpElementType as WithSerializer>::Serializer<'ser>),
            Return(<super::ReturnElementType as WithSerializer>::Serializer<'ser>),
            LeftPowerRail(<super::LeftPowerRailElementType as WithSerializer>::Serializer<'ser>),
            RightPowerRail(<super::RightPowerRailElementType as WithSerializer>::Serializer<'ser>),
            Coil(<super::CoilElementType as WithSerializer>::Serializer<'ser>),
            Contact(<super::CoilElementType as WithSerializer>::Serializer<'ser>),
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> BodyLdElementTypeContentSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        BodyLdElementTypeContentSerializerState::Init__ => match self.value {
                            super::BodyLdElementTypeContent::Comment(x) => {
                                *self.state = BodyLdElementTypeContentSerializerState::Comment(
                                    WithSerializer::serializer(x, Some("comment"), false)?,
                                )
                            }
                            super::BodyLdElementTypeContent::Error(x) => {
                                *self.state = BodyLdElementTypeContentSerializerState::Error(
                                    WithSerializer::serializer(x, Some("error"), false)?,
                                )
                            }
                            super::BodyLdElementTypeContent::Connector(x) => {
                                *self.state = BodyLdElementTypeContentSerializerState::Connector(
                                    WithSerializer::serializer(x, Some("connector"), false)?,
                                )
                            }
                            super::BodyLdElementTypeContent::Continuation(x) => {
                                *self.state = BodyLdElementTypeContentSerializerState::Continuation(
                                    WithSerializer::serializer(x, Some("continuation"), false)?,
                                )
                            }
                            super::BodyLdElementTypeContent::ActionBlock(x) => {
                                *self.state = BodyLdElementTypeContentSerializerState::ActionBlock(
                                    WithSerializer::serializer(x, Some("actionBlock"), false)?,
                                )
                            }
                            super::BodyLdElementTypeContent::VendorElement(x) => {
                                *self.state = BodyLdElementTypeContentSerializerState::VendorElement(
                                    WithSerializer::serializer(x, Some("vendorElement"), false)?,
                                )
                            }
                            super::BodyLdElementTypeContent::Block(x) => {
                                *self.state = BodyLdElementTypeContentSerializerState::Block(
                                    WithSerializer::serializer(x, Some("block"), false)?,
                                )
                            }
                            super::BodyLdElementTypeContent::InVariable(x) => {
                                *self.state = BodyLdElementTypeContentSerializerState::InVariable(
                                    WithSerializer::serializer(x, Some("inVariable"), false)?,
                                )
                            }
                            super::BodyLdElementTypeContent::OutVariable(x) => {
                                *self.state = BodyLdElementTypeContentSerializerState::OutVariable(
                                    WithSerializer::serializer(x, Some("outVariable"), false)?,
                                )
                            }
                            super::BodyLdElementTypeContent::InOutVariable(x) => {
                                *self.state = BodyLdElementTypeContentSerializerState::InOutVariable(
                                    WithSerializer::serializer(x, Some("inOutVariable"), false)?,
                                )
                            }
                            super::BodyLdElementTypeContent::Label(x) => {
                                *self.state = BodyLdElementTypeContentSerializerState::Label(
                                    WithSerializer::serializer(x, Some("label"), false)?,
                                )
                            }
                            super::BodyLdElementTypeContent::Jump(x) => {
                                *self.state = BodyLdElementTypeContentSerializerState::Jump(
                                    WithSerializer::serializer(x, Some("jump"), false)?,
                                )
                            }
                            super::BodyLdElementTypeContent::Return(x) => {
                                *self.state = BodyLdElementTypeContentSerializerState::Return(
                                    WithSerializer::serializer(x, Some("return"), false)?,
                                )
                            }
                            super::BodyLdElementTypeContent::LeftPowerRail(x) => {
                                *self.state = BodyLdElementTypeContentSerializerState::LeftPowerRail(
                                    WithSerializer::serializer(x, Some("leftPowerRail"), false)?,
                                )
                            }
                            super::BodyLdElementTypeContent::RightPowerRail(x) => {
                                *self.state =
                                    BodyLdElementTypeContentSerializerState::RightPowerRail(
                                        WithSerializer::serializer(
                                            x,
                                            Some("rightPowerRail"),
                                            false,
                                        )?,
                                    )
                            }
                            super::BodyLdElementTypeContent::Coil(x) => {
                                *self.state = BodyLdElementTypeContentSerializerState::Coil(
                                    WithSerializer::serializer(x, Some("coil"), false)?,
                                )
                            }
                            super::BodyLdElementTypeContent::Contact(x) => {
                                *self.state = BodyLdElementTypeContentSerializerState::Contact(
                                    WithSerializer::serializer(x, Some("contact"), false)?,
                                )
                            }
                        },
                        BodyLdElementTypeContentSerializerState::Comment(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyLdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyLdElementTypeContentSerializerState::Error(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyLdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyLdElementTypeContentSerializerState::Connector(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyLdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyLdElementTypeContentSerializerState::Continuation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyLdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyLdElementTypeContentSerializerState::ActionBlock(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyLdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyLdElementTypeContentSerializerState::VendorElement(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyLdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyLdElementTypeContentSerializerState::Block(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyLdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyLdElementTypeContentSerializerState::InVariable(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyLdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyLdElementTypeContentSerializerState::OutVariable(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyLdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyLdElementTypeContentSerializerState::InOutVariable(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyLdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyLdElementTypeContentSerializerState::Label(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyLdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyLdElementTypeContentSerializerState::Jump(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyLdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyLdElementTypeContentSerializerState::Return(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyLdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyLdElementTypeContentSerializerState::LeftPowerRail(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyLdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyLdElementTypeContentSerializerState::RightPowerRail(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyLdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyLdElementTypeContentSerializerState::Coil(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyLdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyLdElementTypeContentSerializerState::Contact(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodyLdElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodyLdElementTypeContentSerializerState::Done__ => return Ok(None),
                        BodyLdElementTypeContentSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for BodyLdElementTypeContentSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = BodyLdElementTypeContentSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct BodySfcElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::BodySfcElementType,
            pub(super) state: Box<BodySfcElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum BodySfcElementTypeSerializerState<'ser> {
            Init__,
            Content__(
                IterSerializer<
                    'ser,
                    &'ser [super::BodySfcElementTypeContent],
                    super::BodySfcElementTypeContent,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> BodySfcElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        BodySfcElementTypeSerializerState::Init__ => {
                            *self.state = BodySfcElementTypeSerializerState::Content__(
                                IterSerializer::new(&self.value.content[..], None, false),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        BodySfcElementTypeSerializerState::Content__(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = BodySfcElementTypeSerializerState::End__,
                            }
                        }
                        BodySfcElementTypeSerializerState::End__ => {
                            *self.state = BodySfcElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        BodySfcElementTypeSerializerState::Done__ => return Ok(None),
                        BodySfcElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for BodySfcElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = BodySfcElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct BodySfcElementTypeContentSerializer<'ser> {
            pub(super) value: &'ser super::BodySfcElementTypeContent,
            pub(super) state: Box<BodySfcElementTypeContentSerializerState<'ser>>,
        }
        #[derive(Debug)]
        pub(super) enum BodySfcElementTypeContentSerializerState<'ser> {
            Init__,
            Comment(<super::CommentElementType as WithSerializer>::Serializer<'ser>),
            Error(<super::CommentElementType as WithSerializer>::Serializer<'ser>),
            Connector(<super::ConnectorElementType as WithSerializer>::Serializer<'ser>),
            Continuation(<super::ContinuationElementType as WithSerializer>::Serializer<'ser>),
            ActionBlock(<super::ActionBlockElementType as WithSerializer>::Serializer<'ser>),
            VendorElement(<super::VendorElementElementType as WithSerializer>::Serializer<'ser>),
            Block(<super::BlockElementType as WithSerializer>::Serializer<'ser>),
            InVariable(<super::InVariableElementType as WithSerializer>::Serializer<'ser>),
            OutVariable(<super::OutVariableElementType as WithSerializer>::Serializer<'ser>),
            InOutVariable(<super::InOutVariableElementType as WithSerializer>::Serializer<'ser>),
            Label(<super::LabelElementType as WithSerializer>::Serializer<'ser>),
            Jump(<super::JumpElementType as WithSerializer>::Serializer<'ser>),
            Return(<super::ReturnElementType as WithSerializer>::Serializer<'ser>),
            LeftPowerRail(<super::LeftPowerRailElementType as WithSerializer>::Serializer<'ser>),
            RightPowerRail(<super::RightPowerRailElementType as WithSerializer>::Serializer<'ser>),
            Coil(<super::CoilElementType as WithSerializer>::Serializer<'ser>),
            Contact(<super::CoilElementType as WithSerializer>::Serializer<'ser>),
            Step(<super::StepElementType as WithSerializer>::Serializer<'ser>),
            MacroStep(<super::MacroStepElementType as WithSerializer>::Serializer<'ser>),
            JumpStep(<super::JumpStepElementType as WithSerializer>::Serializer<'ser>),
            Transition(<super::TransitionElementType as WithSerializer>::Serializer<'ser>),
            SelectionDivergence(
                <super::SelectionDivergenceElementType as WithSerializer>::Serializer<'ser>,
            ),
            SelectionConvergence(
                <super::SelectionConvergenceElementType as WithSerializer>::Serializer<'ser>,
            ),
            SimultaneousDivergence(
                <super::SimultaneousDivergenceElementType as WithSerializer>::Serializer<'ser>,
            ),
            SimultaneousConvergence(
                <super::SimultaneousConvergenceElementType as WithSerializer>::Serializer<'ser>,
            ),
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> BodySfcElementTypeContentSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        BodySfcElementTypeContentSerializerState::Init__ => match self.value {
                            super::BodySfcElementTypeContent::Comment(x) => {
                                *self.state = BodySfcElementTypeContentSerializerState::Comment(
                                    WithSerializer::serializer(x, Some("comment"), false)?,
                                )
                            }
                            super::BodySfcElementTypeContent::Error(x) => {
                                *self.state = BodySfcElementTypeContentSerializerState::Error(
                                    WithSerializer::serializer(x, Some("error"), false)?,
                                )
                            }
                            super::BodySfcElementTypeContent::Connector(x) => {
                                *self.state = BodySfcElementTypeContentSerializerState::Connector(
                                    WithSerializer::serializer(x, Some("connector"), false)?,
                                )
                            }
                            super::BodySfcElementTypeContent::Continuation(x) => {
                                *self.state = BodySfcElementTypeContentSerializerState::Continuation(
                                    WithSerializer::serializer(x, Some("continuation"), false)?,
                                )
                            }
                            super::BodySfcElementTypeContent::ActionBlock(x) => {
                                *self.state = BodySfcElementTypeContentSerializerState::ActionBlock(
                                    WithSerializer::serializer(x, Some("actionBlock"), false)?,
                                )
                            }
                            super::BodySfcElementTypeContent::VendorElement(x) => {
                                *self.state =
                                    BodySfcElementTypeContentSerializerState::VendorElement(
                                        WithSerializer::serializer(
                                            x,
                                            Some("vendorElement"),
                                            false,
                                        )?,
                                    )
                            }
                            super::BodySfcElementTypeContent::Block(x) => {
                                *self.state = BodySfcElementTypeContentSerializerState::Block(
                                    WithSerializer::serializer(x, Some("block"), false)?,
                                )
                            }
                            super::BodySfcElementTypeContent::InVariable(x) => {
                                *self.state = BodySfcElementTypeContentSerializerState::InVariable(
                                    WithSerializer::serializer(x, Some("inVariable"), false)?,
                                )
                            }
                            super::BodySfcElementTypeContent::OutVariable(x) => {
                                *self.state = BodySfcElementTypeContentSerializerState::OutVariable(
                                    WithSerializer::serializer(x, Some("outVariable"), false)?,
                                )
                            }
                            super::BodySfcElementTypeContent::InOutVariable(x) => {
                                *self.state =
                                    BodySfcElementTypeContentSerializerState::InOutVariable(
                                        WithSerializer::serializer(
                                            x,
                                            Some("inOutVariable"),
                                            false,
                                        )?,
                                    )
                            }
                            super::BodySfcElementTypeContent::Label(x) => {
                                *self.state = BodySfcElementTypeContentSerializerState::Label(
                                    WithSerializer::serializer(x, Some("label"), false)?,
                                )
                            }
                            super::BodySfcElementTypeContent::Jump(x) => {
                                *self.state = BodySfcElementTypeContentSerializerState::Jump(
                                    WithSerializer::serializer(x, Some("jump"), false)?,
                                )
                            }
                            super::BodySfcElementTypeContent::Return(x) => {
                                *self.state = BodySfcElementTypeContentSerializerState::Return(
                                    WithSerializer::serializer(x, Some("return"), false)?,
                                )
                            }
                            super::BodySfcElementTypeContent::LeftPowerRail(x) => {
                                *self.state =
                                    BodySfcElementTypeContentSerializerState::LeftPowerRail(
                                        WithSerializer::serializer(
                                            x,
                                            Some("leftPowerRail"),
                                            false,
                                        )?,
                                    )
                            }
                            super::BodySfcElementTypeContent::RightPowerRail(x) => {
                                *self.state =
                                    BodySfcElementTypeContentSerializerState::RightPowerRail(
                                        WithSerializer::serializer(
                                            x,
                                            Some("rightPowerRail"),
                                            false,
                                        )?,
                                    )
                            }
                            super::BodySfcElementTypeContent::Coil(x) => {
                                *self.state = BodySfcElementTypeContentSerializerState::Coil(
                                    WithSerializer::serializer(x, Some("coil"), false)?,
                                )
                            }
                            super::BodySfcElementTypeContent::Contact(x) => {
                                *self.state = BodySfcElementTypeContentSerializerState::Contact(
                                    WithSerializer::serializer(x, Some("contact"), false)?,
                                )
                            }
                            super::BodySfcElementTypeContent::Step(x) => {
                                *self.state = BodySfcElementTypeContentSerializerState::Step(
                                    WithSerializer::serializer(x, Some("step"), false)?,
                                )
                            }
                            super::BodySfcElementTypeContent::MacroStep(x) => {
                                *self.state = BodySfcElementTypeContentSerializerState::MacroStep(
                                    WithSerializer::serializer(x, Some("macroStep"), false)?,
                                )
                            }
                            super::BodySfcElementTypeContent::JumpStep(x) => {
                                *self.state = BodySfcElementTypeContentSerializerState::JumpStep(
                                    WithSerializer::serializer(x, Some("jumpStep"), false)?,
                                )
                            }
                            super::BodySfcElementTypeContent::Transition(x) => {
                                *self.state = BodySfcElementTypeContentSerializerState::Transition(
                                    WithSerializer::serializer(x, Some("transition"), false)?,
                                )
                            }
                            super::BodySfcElementTypeContent::SelectionDivergence(x) => {
                                *self.state =
                                    BodySfcElementTypeContentSerializerState::SelectionDivergence(
                                        WithSerializer::serializer(
                                            x,
                                            Some("selectionDivergence"),
                                            false,
                                        )?,
                                    )
                            }
                            super::BodySfcElementTypeContent::SelectionConvergence(x) => {
                                *self.state =
                                    BodySfcElementTypeContentSerializerState::SelectionConvergence(
                                        WithSerializer::serializer(
                                            x,
                                            Some("selectionConvergence"),
                                            false,
                                        )?,
                                    )
                            }
                            super::BodySfcElementTypeContent::SimultaneousDivergence(x) => {
                                *self.state =
                                    BodySfcElementTypeContentSerializerState::SimultaneousDivergence(
                                        WithSerializer::serializer(
                                            x,
                                            Some("simultaneousDivergence"),
                                            false,
                                        )?,
                                    )
                            }
                            super::BodySfcElementTypeContent::SimultaneousConvergence(x) => *self
                                .state =
                                BodySfcElementTypeContentSerializerState::SimultaneousConvergence(
                                    WithSerializer::serializer(
                                        x,
                                        Some("simultaneousConvergence"),
                                        false,
                                    )?,
                                ),
                        },
                        BodySfcElementTypeContentSerializerState::Comment(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::Error(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::Connector(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::Continuation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::ActionBlock(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::VendorElement(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::Block(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::InVariable(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::OutVariable(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::InOutVariable(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::Label(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::Jump(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::Return(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::LeftPowerRail(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::RightPowerRail(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::Coil(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::Contact(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::Step(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::MacroStep(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::JumpStep(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::Transition(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::SelectionDivergence(x) => match x
                            .next()
                            .transpose()?
                        {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = BodySfcElementTypeContentSerializerState::Done__,
                        },
                        BodySfcElementTypeContentSerializerState::SelectionConvergence(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::SimultaneousDivergence(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::SimultaneousConvergence(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BodySfcElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        BodySfcElementTypeContentSerializerState::Done__ => return Ok(None),
                        BodySfcElementTypeContentSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for BodySfcElementTypeContentSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = BodySfcElementTypeContentSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct StringElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::StringElementType,
            pub(super) state: Box<StringElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum StringElementTypeSerializerState<'ser> {
            Init__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> StringElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        StringElementTypeSerializerState::Init__ => {
                            *self.state = StringElementTypeSerializerState::Done__;
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib_opt(&mut bytes, "length", &self.value.length)?;
                            return Ok(Some(Event::Empty(bytes)));
                        }
                        StringElementTypeSerializerState::Done__ => return Ok(None),
                        StringElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for StringElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = StringElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ArrayElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ArrayElementType,
            pub(super) state: Box<ArrayElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ArrayElementTypeSerializerState<'ser> {
            Init__,
            Dimension(IterSerializer<'ser, &'ser [super::RangeSignedType], super::RangeSignedType>),
            BaseType(<super::DataType as WithSerializer>::Serializer<'ser>),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ArrayElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ArrayElementTypeSerializerState::Init__ => {
                            *self.state =
                                ArrayElementTypeSerializerState::Dimension(IterSerializer::new(
                                    &self.value.dimension[..],
                                    Some("dimension"),
                                    false,
                                ));
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ArrayElementTypeSerializerState::Dimension(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = ArrayElementTypeSerializerState::BaseType(
                                        WithSerializer::serializer(
                                            &*self.value.base_type,
                                            Some("baseType"),
                                            false,
                                        )?,
                                    )
                                }
                            }
                        }
                        ArrayElementTypeSerializerState::BaseType(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = ArrayElementTypeSerializerState::End__,
                            }
                        }
                        ArrayElementTypeSerializerState::End__ => {
                            *self.state = ArrayElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ArrayElementTypeSerializerState::Done__ => return Ok(None),
                        ArrayElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ArrayElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ArrayElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct DerivedElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::DerivedElementType,
            pub(super) state: Box<DerivedElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum DerivedElementTypeSerializerState<'ser> {
            Init__,
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> DerivedElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        DerivedElementTypeSerializerState::Init__ => {
                            *self.state =
                                DerivedElementTypeSerializerState::AddData(IterSerializer::new(
                                    self.value.add_data.as_ref(),
                                    Some("addData"),
                                    false,
                                ));
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "name", &self.value.name)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        DerivedElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = DerivedElementTypeSerializerState::End__,
                            }
                        }
                        DerivedElementTypeSerializerState::End__ => {
                            *self.state = DerivedElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        DerivedElementTypeSerializerState::Done__ => return Ok(None),
                        DerivedElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for DerivedElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = DerivedElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct EnumElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::EnumElementType,
            pub(super) state: Box<EnumElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum EnumElementTypeSerializerState<'ser> {
            Init__,
            Values(<super::EnumValuesElementType as WithSerializer>::Serializer<'ser>),
            BaseType(IterSerializer<'ser, Option<&'ser super::DataType>, super::DataType>),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> EnumElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        EnumElementTypeSerializerState::Init__ => {
                            *self.state =
                                EnumElementTypeSerializerState::Values(WithSerializer::serializer(
                                    &self.value.values,
                                    Some("values"),
                                    false,
                                )?);
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        EnumElementTypeSerializerState::Values(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    EnumElementTypeSerializerState::BaseType(IterSerializer::new(
                                        self.value.base_type.as_ref().map(|x| &**x),
                                        Some("baseType"),
                                        false,
                                    ))
                            }
                        },
                        EnumElementTypeSerializerState::BaseType(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = EnumElementTypeSerializerState::End__,
                            }
                        }
                        EnumElementTypeSerializerState::End__ => {
                            *self.state = EnumElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        EnumElementTypeSerializerState::Done__ => return Ok(None),
                        EnumElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for EnumElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = EnumElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct SubrangeSignedElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::SubrangeSignedElementType,
            pub(super) state: Box<SubrangeSignedElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum SubrangeSignedElementTypeSerializerState<'ser> {
            Init__,
            Range(<super::RangeSignedType as WithSerializer>::Serializer<'ser>),
            BaseType(<super::DataType as WithSerializer>::Serializer<'ser>),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> SubrangeSignedElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        SubrangeSignedElementTypeSerializerState::Init__ => {
                            *self.state = SubrangeSignedElementTypeSerializerState::Range(
                                WithSerializer::serializer(
                                    &self.value.range,
                                    Some("range"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        SubrangeSignedElementTypeSerializerState::Range(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = SubrangeSignedElementTypeSerializerState::BaseType(
                                        WithSerializer::serializer(
                                            &*self.value.base_type,
                                            Some("baseType"),
                                            false,
                                        )?,
                                    )
                                }
                            }
                        }
                        SubrangeSignedElementTypeSerializerState::BaseType(x) => match x
                            .next()
                            .transpose()?
                        {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = SubrangeSignedElementTypeSerializerState::End__,
                        },
                        SubrangeSignedElementTypeSerializerState::End__ => {
                            *self.state = SubrangeSignedElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        SubrangeSignedElementTypeSerializerState::Done__ => return Ok(None),
                        SubrangeSignedElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for SubrangeSignedElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = SubrangeSignedElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct PointerElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::PointerElementType,
            pub(super) state: Box<PointerElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum PointerElementTypeSerializerState<'ser> {
            Init__,
            BaseType(<super::DataType as WithSerializer>::Serializer<'ser>),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> PointerElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        PointerElementTypeSerializerState::Init__ => {
                            *self.state = PointerElementTypeSerializerState::BaseType(
                                WithSerializer::serializer(
                                    &*self.value.base_type,
                                    Some("baseType"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        PointerElementTypeSerializerState::BaseType(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = PointerElementTypeSerializerState::End__,
                            }
                        }
                        PointerElementTypeSerializerState::End__ => {
                            *self.state = PointerElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        PointerElementTypeSerializerState::Done__ => return Ok(None),
                        PointerElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for PointerElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = PointerElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectFileHeaderElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectFileHeaderElementType,
            pub(super) state: Box<ProjectFileHeaderElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectFileHeaderElementTypeSerializerState<'ser> {
            Init__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ProjectFileHeaderElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ProjectFileHeaderElementTypeSerializerState::Init__ => {
                            *self.state = ProjectFileHeaderElementTypeSerializerState::Done__;
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "companyName", &self.value.company_name)?;
                            write_attrib_opt(&mut bytes, "companyURL", &self.value.company_url)?;
                            write_attrib(&mut bytes, "productName", &self.value.product_name)?;
                            write_attrib(
                                &mut bytes,
                                "productVersion",
                                &self.value.product_version,
                            )?;
                            write_attrib_opt(
                                &mut bytes,
                                "productRelease",
                                &self.value.product_release,
                            )?;
                            write_attrib(
                                &mut bytes,
                                "creationDateTime",
                                &self.value.creation_date_time,
                            )?;
                            write_attrib_opt(
                                &mut bytes,
                                "contentDescription",
                                &self.value.content_description,
                            )?;
                            return Ok(Some(Event::Empty(bytes)));
                        }
                        ProjectFileHeaderElementTypeSerializerState::Done__ => return Ok(None),
                        ProjectFileHeaderElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ProjectFileHeaderElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ProjectFileHeaderElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectContentHeaderElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectContentHeaderElementType,
            pub(super) state: Box<ProjectContentHeaderElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectContentHeaderElementTypeSerializerState<'ser> {
            Init__ , Comment (IterSerializer < 'ser , Option < & 'ser :: std :: string :: String > , :: std :: string :: String >) , CoordinateInfo (< super :: ProjectContentHeaderCoordinateInfoElementType as WithSerializer > :: Serializer < 'ser >) , AddDataInfo (IterSerializer < 'ser , Option < & 'ser super :: AddDataInfoType > , super :: AddDataInfoType >) , AddData (IterSerializer < 'ser , Option < & 'ser super :: AddDataType > , super :: AddDataType >) , End__ , Done__ , Phantom__ (& 'ser ()) , }
        impl<'ser> ProjectContentHeaderElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ProjectContentHeaderElementTypeSerializerState::Init__ => {
                            *self.state = ProjectContentHeaderElementTypeSerializerState::Comment(
                                IterSerializer::new(
                                    self.value.comment.as_ref(),
                                    Some("Comment"),
                                    false,
                                ),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "name", &self.value.name)?;
                            write_attrib_opt(&mut bytes, "version", &self.value.version)?;
                            write_attrib_opt(
                                &mut bytes,
                                "modificationDateTime",
                                &self.value.modification_date_time,
                            )?;
                            write_attrib_opt(&mut bytes, "organization", &self.value.organization)?;
                            write_attrib_opt(&mut bytes, "author", &self.value.author)?;
                            write_attrib_opt(&mut bytes, "language", &self.value.language)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ProjectContentHeaderElementTypeSerializerState::Comment(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state =
                                    ProjectContentHeaderElementTypeSerializerState::CoordinateInfo(
                                        WithSerializer::serializer(
                                            &self.value.coordinate_info,
                                            Some("coordinateInfo"),
                                            false,
                                        )?,
                                    ),
                            }
                        }
                        ProjectContentHeaderElementTypeSerializerState::CoordinateInfo(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ProjectContentHeaderElementTypeSerializerState::AddDataInfo(
                                            IterSerializer::new(
                                                self.value.add_data_info.as_ref(),
                                                Some("addDataInfo"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        ProjectContentHeaderElementTypeSerializerState::AddDataInfo(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ProjectContentHeaderElementTypeSerializerState::AddData(
                                            IterSerializer::new(
                                                self.value.add_data.as_ref(),
                                                Some("addData"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        ProjectContentHeaderElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ProjectContentHeaderElementTypeSerializerState::End__
                                }
                            }
                        }
                        ProjectContentHeaderElementTypeSerializerState::End__ => {
                            *self.state = ProjectContentHeaderElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ProjectContentHeaderElementTypeSerializerState::Done__ => return Ok(None),
                        ProjectContentHeaderElementTypeSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for ProjectContentHeaderElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ProjectContentHeaderElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectTypesElementType,
            pub(super) state: Box<ProjectTypesElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectTypesElementTypeSerializerState<'ser> {
            Init__,
            DataTypes(
                <super::ProjectTypesDataTypesElementType as WithSerializer>::Serializer<'ser>,
            ),
            Pous(<super::ProjectTypesPousElementType as WithSerializer>::Serializer<'ser>),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ProjectTypesElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ProjectTypesElementTypeSerializerState::Init__ => {
                            *self.state = ProjectTypesElementTypeSerializerState::DataTypes(
                                WithSerializer::serializer(
                                    &self.value.data_types,
                                    Some("dataTypes"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ProjectTypesElementTypeSerializerState::DataTypes(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = ProjectTypesElementTypeSerializerState::Pous(
                                        WithSerializer::serializer(
                                            &self.value.pous,
                                            Some("pous"),
                                            false,
                                        )?,
                                    )
                                }
                            }
                        }
                        ProjectTypesElementTypeSerializerState::Pous(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = ProjectTypesElementTypeSerializerState::End__,
                            }
                        }
                        ProjectTypesElementTypeSerializerState::End__ => {
                            *self.state = ProjectTypesElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ProjectTypesElementTypeSerializerState::Done__ => return Ok(None),
                        ProjectTypesElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ProjectTypesElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ProjectTypesElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectInstancesElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectInstancesElementType,
            pub(super) state: Box<ProjectInstancesElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectInstancesElementTypeSerializerState<'ser> {
            Init__,
            Configurations(
                <super::ProjectInstancesConfigurationsElementType as WithSerializer>::Serializer<
                    'ser,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ProjectInstancesElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ProjectInstancesElementTypeSerializerState::Init__ => {
                            *self.state =
                                ProjectInstancesElementTypeSerializerState::Configurations(
                                    WithSerializer::serializer(
                                        &self.value.configurations,
                                        Some("configurations"),
                                        false,
                                    )?,
                                );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ProjectInstancesElementTypeSerializerState::Configurations(x) => match x
                            .next()
                            .transpose()?
                        {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = ProjectInstancesElementTypeSerializerState::End__,
                        },
                        ProjectInstancesElementTypeSerializerState::End__ => {
                            *self.state = ProjectInstancesElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ProjectInstancesElementTypeSerializerState::Done__ => return Ok(None),
                        ProjectInstancesElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ProjectInstancesElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ProjectInstancesElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ValueSimpleValueElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ValueSimpleValueElementType,
            pub(super) state: Box<ValueSimpleValueElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ValueSimpleValueElementTypeSerializerState<'ser> {
            Init__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ValueSimpleValueElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ValueSimpleValueElementTypeSerializerState::Init__ => {
                            *self.state = ValueSimpleValueElementTypeSerializerState::Done__;
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib_opt(&mut bytes, "value", &self.value.value)?;
                            return Ok(Some(Event::Empty(bytes)));
                        }
                        ValueSimpleValueElementTypeSerializerState::Done__ => return Ok(None),
                        ValueSimpleValueElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ValueSimpleValueElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ValueSimpleValueElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ValueArrayValueElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ValueArrayValueElementType,
            pub(super) state: Box<ValueArrayValueElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ValueArrayValueElementTypeSerializerState<'ser> {
            Init__,
            Content__(
                IterSerializer<
                    'ser,
                    &'ser [super::ValueArrayValueElementTypeContent],
                    super::ValueArrayValueElementTypeContent,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ValueArrayValueElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ValueArrayValueElementTypeSerializerState::Init__ => {
                            *self.state = ValueArrayValueElementTypeSerializerState::Content__(
                                IterSerializer::new(&self.value.content[..], None, false),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ValueArrayValueElementTypeSerializerState::Content__(x) => match x
                            .next()
                            .transpose()?
                        {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = ValueArrayValueElementTypeSerializerState::End__,
                        },
                        ValueArrayValueElementTypeSerializerState::End__ => {
                            *self.state = ValueArrayValueElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ValueArrayValueElementTypeSerializerState::Done__ => return Ok(None),
                        ValueArrayValueElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ValueArrayValueElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ValueArrayValueElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ValueArrayValueElementTypeContentSerializer<'ser> {
            pub(super) value: &'ser super::ValueArrayValueElementTypeContent,
            pub(super) state: Box<ValueArrayValueElementTypeContentSerializerState<'ser>>,
        }
        #[derive(Debug)]
        pub(super) enum ValueArrayValueElementTypeContentSerializerState<'ser> {
            Init__,
            Value(<super::ValueArrayValueValueElementType as WithSerializer>::Serializer<'ser>),
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ValueArrayValueElementTypeContentSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ValueArrayValueElementTypeContentSerializerState::Init__ => {
                            *self.state = ValueArrayValueElementTypeContentSerializerState::Value(
                                WithSerializer::serializer(
                                    &self.value.value,
                                    Some("value"),
                                    false,
                                )?,
                            );
                        }
                        ValueArrayValueElementTypeContentSerializerState::Value(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ValueArrayValueElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        ValueArrayValueElementTypeContentSerializerState::Done__ => {
                            return Ok(None)
                        }
                        ValueArrayValueElementTypeContentSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for ValueArrayValueElementTypeContentSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ValueArrayValueElementTypeContentSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ValueStructValueElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ValueStructValueElementType,
            pub(super) state: Box<ValueStructValueElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ValueStructValueElementTypeSerializerState<'ser> {
            Init__,
            Content__(
                IterSerializer<
                    'ser,
                    &'ser [super::ValueStructValueElementTypeContent],
                    super::ValueStructValueElementTypeContent,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ValueStructValueElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ValueStructValueElementTypeSerializerState::Init__ => {
                            *self.state = ValueStructValueElementTypeSerializerState::Content__(
                                IterSerializer::new(&self.value.content[..], None, false),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ValueStructValueElementTypeSerializerState::Content__(x) => match x
                            .next()
                            .transpose(
                        )? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = ValueStructValueElementTypeSerializerState::End__,
                        },
                        ValueStructValueElementTypeSerializerState::End__ => {
                            *self.state = ValueStructValueElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ValueStructValueElementTypeSerializerState::Done__ => return Ok(None),
                        ValueStructValueElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ValueStructValueElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ValueStructValueElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ValueStructValueElementTypeContentSerializer<'ser> {
            pub(super) value: &'ser super::ValueStructValueElementTypeContent,
            pub(super) state: Box<ValueStructValueElementTypeContentSerializerState<'ser>>,
        }
        #[derive(Debug)]
        pub(super) enum ValueStructValueElementTypeContentSerializerState<'ser> {
            Init__,
            Value(<super::ValueStructValueValueElementType as WithSerializer>::Serializer<'ser>),
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ValueStructValueElementTypeContentSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ValueStructValueElementTypeContentSerializerState::Init__ => {
                            *self.state = ValueStructValueElementTypeContentSerializerState::Value(
                                WithSerializer::serializer(
                                    &self.value.value,
                                    Some("value"),
                                    false,
                                )?,
                            );
                        }
                        ValueStructValueElementTypeContentSerializerState::Value(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ValueStructValueElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        ValueStructValueElementTypeContentSerializerState::Done__ => {
                            return Ok(None)
                        }
                        ValueStructValueElementTypeContentSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for ValueStructValueElementTypeContentSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ValueStructValueElementTypeContentSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct VarListPlainVariableElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::VarListPlainVariableElementType,
            pub(super) state: Box<VarListPlainVariableElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum VarListPlainVariableElementTypeSerializerState<'ser> {
            Init__,
            Type(<super::DataType as WithSerializer>::Serializer<'ser>),
            InitialValue(IterSerializer<'ser, Option<&'ser super::ValueType>, super::ValueType>),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> VarListPlainVariableElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        VarListPlainVariableElementTypeSerializerState::Init__ => {
                            *self.state = VarListPlainVariableElementTypeSerializerState::Type(
                                WithSerializer::serializer(&self.value.type_, Some("type"), false)?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "name", &self.value.name)?;
                            write_attrib_opt(&mut bytes, "address", &self.value.address)?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        VarListPlainVariableElementTypeSerializerState::Type(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        VarListPlainVariableElementTypeSerializerState::InitialValue(
                                            IterSerializer::new(
                                                self.value.initial_value.as_ref(),
                                                Some("initialValue"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        VarListPlainVariableElementTypeSerializerState::InitialValue(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        VarListPlainVariableElementTypeSerializerState::AddData(
                                            IterSerializer::new(
                                                self.value.add_data.as_ref(),
                                                Some("addData"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        VarListPlainVariableElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state =
                                    VarListPlainVariableElementTypeSerializerState::Documentation(
                                        IterSerializer::new(
                                            self.value.documentation.as_ref(),
                                            Some("documentation"),
                                            false,
                                        ),
                                    ),
                            }
                        }
                        VarListPlainVariableElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        VarListPlainVariableElementTypeSerializerState::End__
                                }
                            }
                        }
                        VarListPlainVariableElementTypeSerializerState::End__ => {
                            *self.state = VarListPlainVariableElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        VarListPlainVariableElementTypeSerializerState::Done__ => return Ok(None),
                        VarListPlainVariableElementTypeSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for VarListPlainVariableElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = VarListPlainVariableElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct VarListAccessAccessVariableElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::VarListAccessAccessVariableElementType,
            pub(super) state: Box<VarListAccessAccessVariableElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum VarListAccessAccessVariableElementTypeSerializerState<'ser> {
            Init__,
            Type(<super::DataType as WithSerializer>::Serializer<'ser>),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> VarListAccessAccessVariableElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { VarListAccessAccessVariableElementTypeSerializerState :: Init__ => { * self . state = VarListAccessAccessVariableElementTypeSerializerState :: Type (WithSerializer :: serializer (& self . value . type_ , Some ("type") , false) ?) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } write_attrib (& mut bytes , "alias" , & self . value . alias) ? ; write_attrib (& mut bytes , "instancePathAndName" , & self . value . instance_path_and_name) ? ; write_attrib_opt (& mut bytes , "direction" , & self . value . direction) ? ; return Ok (Some (Event :: Start (bytes))) } VarListAccessAccessVariableElementTypeSerializerState :: Type (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = VarListAccessAccessVariableElementTypeSerializerState :: AddData (IterSerializer :: new (self . value . add_data . as_ref () , Some ("addData") , false)) , } VarListAccessAccessVariableElementTypeSerializerState :: AddData (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = VarListAccessAccessVariableElementTypeSerializerState :: Documentation (IterSerializer :: new (self . value . documentation . as_ref () , Some ("documentation") , false)) , } VarListAccessAccessVariableElementTypeSerializerState :: Documentation (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = VarListAccessAccessVariableElementTypeSerializerState :: End__ , } VarListAccessAccessVariableElementTypeSerializerState :: End__ => { * self . state = VarListAccessAccessVariableElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } VarListAccessAccessVariableElementTypeSerializerState :: Done__ => return Ok (None) , VarListAccessAccessVariableElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for VarListAccessAccessVariableElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = VarListAccessAccessVariableElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct VarListConfigConfigVariableElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::VarListConfigConfigVariableElementType,
            pub(super) state: Box<VarListConfigConfigVariableElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum VarListConfigConfigVariableElementTypeSerializerState<'ser> {
            Init__,
            Type(<super::DataType as WithSerializer>::Serializer<'ser>),
            InitialValue(IterSerializer<'ser, Option<&'ser super::ValueType>, super::ValueType>),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> VarListConfigConfigVariableElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { VarListConfigConfigVariableElementTypeSerializerState :: Init__ => { * self . state = VarListConfigConfigVariableElementTypeSerializerState :: Type (WithSerializer :: serializer (& self . value . type_ , Some ("type") , false) ?) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } write_attrib (& mut bytes , "instancePathAndName" , & self . value . instance_path_and_name) ? ; write_attrib_opt (& mut bytes , "address" , & self . value . address) ? ; return Ok (Some (Event :: Start (bytes))) } VarListConfigConfigVariableElementTypeSerializerState :: Type (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = VarListConfigConfigVariableElementTypeSerializerState :: InitialValue (IterSerializer :: new (self . value . initial_value . as_ref () , Some ("initialValue") , false)) , } VarListConfigConfigVariableElementTypeSerializerState :: InitialValue (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = VarListConfigConfigVariableElementTypeSerializerState :: AddData (IterSerializer :: new (self . value . add_data . as_ref () , Some ("addData") , false)) , } VarListConfigConfigVariableElementTypeSerializerState :: AddData (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = VarListConfigConfigVariableElementTypeSerializerState :: Documentation (IterSerializer :: new (self . value . documentation . as_ref () , Some ("documentation") , false)) , } VarListConfigConfigVariableElementTypeSerializerState :: Documentation (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = VarListConfigConfigVariableElementTypeSerializerState :: End__ , } VarListConfigConfigVariableElementTypeSerializerState :: End__ => { * self . state = VarListConfigConfigVariableElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } VarListConfigConfigVariableElementTypeSerializerState :: Done__ => return Ok (None) , VarListConfigConfigVariableElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for VarListConfigConfigVariableElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = VarListConfigConfigVariableElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct CommentElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::CommentElementType,
            pub(super) state: Box<CommentElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum CommentElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            Content(<super::FormattedTextType as WithSerializer>::Serializer<'ser>),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> CommentElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        CommentElementTypeSerializerState::Init__ => {
                            *self.state = CommentElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib(&mut bytes, "height", &self.value.height)?;
                            write_attrib(&mut bytes, "width", &self.value.width)?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        CommentElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = CommentElementTypeSerializerState::Content(
                                        WithSerializer::serializer(
                                            &self.value.content,
                                            Some("content"),
                                            false,
                                        )?,
                                    )
                                }
                            }
                        }
                        CommentElementTypeSerializerState::Content(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = CommentElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        CommentElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = CommentElementTypeSerializerState::Documentation(
                                        IterSerializer::new(
                                            self.value.documentation.as_ref(),
                                            Some("documentation"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        CommentElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = CommentElementTypeSerializerState::End__,
                            }
                        }
                        CommentElementTypeSerializerState::End__ => {
                            *self.state = CommentElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        CommentElementTypeSerializerState::Done__ => return Ok(None),
                        CommentElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for CommentElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = CommentElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ConnectorElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ConnectorElementType,
            pub(super) state: Box<ConnectorElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ConnectorElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointIn(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointInType>,
                    super::ConnectionPointInType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ConnectorElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ConnectorElementTypeSerializerState::Init__ => {
                            *self.state = ConnectorElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "name", &self.value.name)?;
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ConnectorElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ConnectorElementTypeSerializerState::ConnectionPointIn(
                                            IterSerializer::new(
                                                self.value.connection_point_in.as_ref(),
                                                Some("connectionPointIn"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        ConnectorElementTypeSerializerState::ConnectionPointIn(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = ConnectorElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        ConnectorElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = ConnectorElementTypeSerializerState::Documentation(
                                        IterSerializer::new(
                                            self.value.documentation.as_ref(),
                                            Some("documentation"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        ConnectorElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = ConnectorElementTypeSerializerState::End__,
                            }
                        }
                        ConnectorElementTypeSerializerState::End__ => {
                            *self.state = ConnectorElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ConnectorElementTypeSerializerState::Done__ => return Ok(None),
                        ConnectorElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ConnectorElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ConnectorElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ContinuationElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ContinuationElementType,
            pub(super) state: Box<ContinuationElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ContinuationElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointOut(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointOutType>,
                    super::ConnectionPointOutType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ContinuationElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ContinuationElementTypeSerializerState::Init__ => {
                            *self.state = ContinuationElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "name", &self.value.name)?;
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ContinuationElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ContinuationElementTypeSerializerState::ConnectionPointOut(
                                            IterSerializer::new(
                                                self.value.connection_point_out.as_ref(),
                                                Some("connectionPointOut"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        ContinuationElementTypeSerializerState::ConnectionPointOut(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = ContinuationElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        ContinuationElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ContinuationElementTypeSerializerState::Documentation(
                                            IterSerializer::new(
                                                self.value.documentation.as_ref(),
                                                Some("documentation"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        ContinuationElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = ContinuationElementTypeSerializerState::End__,
                            }
                        }
                        ContinuationElementTypeSerializerState::End__ => {
                            *self.state = ContinuationElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ContinuationElementTypeSerializerState::Done__ => return Ok(None),
                        ContinuationElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ContinuationElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ContinuationElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ActionBlockElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ActionBlockElementType,
            pub(super) state: Box<ActionBlockElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ActionBlockElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointIn(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointInType>,
                    super::ConnectionPointInType,
                >,
            ),
            Action(
                IterSerializer<
                    'ser,
                    &'ser [super::ActionBlockActionElementType],
                    super::ActionBlockActionElementType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ActionBlockElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ActionBlockElementTypeSerializerState::Init__ => {
                            *self.state = ActionBlockElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib(&mut bytes, "negated", &self.value.negated)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(
                                &mut bytes,
                                "executionOrderId",
                                &self.value.execution_order_id,
                            )?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ActionBlockElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ActionBlockElementTypeSerializerState::ConnectionPointIn(
                                            IterSerializer::new(
                                                self.value.connection_point_in.as_ref(),
                                                Some("connectionPointIn"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        ActionBlockElementTypeSerializerState::ConnectionPointIn(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = ActionBlockElementTypeSerializerState::Action(
                                        IterSerializer::new(
                                            &self.value.action[..],
                                            Some("action"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        ActionBlockElementTypeSerializerState::Action(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = ActionBlockElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        ActionBlockElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ActionBlockElementTypeSerializerState::Documentation(
                                            IterSerializer::new(
                                                self.value.documentation.as_ref(),
                                                Some("documentation"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        ActionBlockElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = ActionBlockElementTypeSerializerState::End__,
                            }
                        }
                        ActionBlockElementTypeSerializerState::End__ => {
                            *self.state = ActionBlockElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ActionBlockElementTypeSerializerState::Done__ => return Ok(None),
                        ActionBlockElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ActionBlockElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ActionBlockElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct VendorElementElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::VendorElementElementType,
            pub(super) state: Box<VendorElementElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum VendorElementElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            AlternativeText(<super::FormattedTextType as WithSerializer>::Serializer<'ser>),
            InputVariables(
                IterSerializer<
                    'ser,
                    Option<&'ser super::BlockInputVariablesElementType>,
                    super::BlockInputVariablesElementType,
                >,
            ),
            InOutVariables(
                IterSerializer<
                    'ser,
                    Option<&'ser super::BlockInOutVariablesElementType>,
                    super::BlockInOutVariablesElementType,
                >,
            ),
            OutputVariables(
                IterSerializer<
                    'ser,
                    Option<&'ser super::BlockOutputVariablesElementType>,
                    super::BlockOutputVariablesElementType,
                >,
            ),
            AddData(<super::AddDataType as WithSerializer>::Serializer<'ser>),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> VendorElementElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        VendorElementElementTypeSerializerState::Init__ => {
                            *self.state = VendorElementElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(
                                &mut bytes,
                                "executionOrderId",
                                &self.value.execution_order_id,
                            )?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        VendorElementElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        VendorElementElementTypeSerializerState::AlternativeText(
                                            WithSerializer::serializer(
                                                &self.value.alternative_text,
                                                Some("alternativeText"),
                                                false,
                                            )?,
                                        )
                                }
                            }
                        }
                        VendorElementElementTypeSerializerState::AlternativeText(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        VendorElementElementTypeSerializerState::InputVariables(
                                            IterSerializer::new(
                                                self.value.input_variables.as_ref(),
                                                Some("inputVariables"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        VendorElementElementTypeSerializerState::InputVariables(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        VendorElementElementTypeSerializerState::InOutVariables(
                                            IterSerializer::new(
                                                self.value.in_out_variables.as_ref(),
                                                Some("inOutVariables"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        VendorElementElementTypeSerializerState::InOutVariables(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        VendorElementElementTypeSerializerState::OutputVariables(
                                            IterSerializer::new(
                                                self.value.output_variables.as_ref(),
                                                Some("outputVariables"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        VendorElementElementTypeSerializerState::OutputVariables(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = VendorElementElementTypeSerializerState::AddData(
                                        WithSerializer::serializer(
                                            &self.value.add_data,
                                            Some("addData"),
                                            false,
                                        )?,
                                    )
                                }
                            }
                        }
                        VendorElementElementTypeSerializerState::AddData(x) => match x
                            .next()
                            .transpose()?
                        {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = VendorElementElementTypeSerializerState::End__,
                        },
                        VendorElementElementTypeSerializerState::End__ => {
                            *self.state = VendorElementElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        VendorElementElementTypeSerializerState::Done__ => return Ok(None),
                        VendorElementElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for VendorElementElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = VendorElementElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct BlockElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::BlockElementType,
            pub(super) state: Box<BlockElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum BlockElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            InputVariables(
                <super::BlockInputVariablesElementType as WithSerializer>::Serializer<'ser>,
            ),
            InOutVariables(
                <super::BlockInOutVariablesElementType as WithSerializer>::Serializer<'ser>,
            ),
            OutputVariables(
                <super::BlockOutputVariablesElementType as WithSerializer>::Serializer<'ser>,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> BlockElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        BlockElementTypeSerializerState::Init__ => {
                            *self.state = BlockElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib(&mut bytes, "typeName", &self.value.type_name)?;
                            write_attrib_opt(
                                &mut bytes,
                                "instanceName",
                                &self.value.instance_name,
                            )?;
                            write_attrib_opt(
                                &mut bytes,
                                "executionOrderId",
                                &self.value.execution_order_id,
                            )?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        BlockElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BlockElementTypeSerializerState::InputVariables(
                                        WithSerializer::serializer(
                                            &self.value.input_variables,
                                            Some("inputVariables"),
                                            false,
                                        )?,
                                    )
                                }
                            }
                        }
                        BlockElementTypeSerializerState::InputVariables(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BlockElementTypeSerializerState::InOutVariables(
                                        WithSerializer::serializer(
                                            &self.value.in_out_variables,
                                            Some("inOutVariables"),
                                            false,
                                        )?,
                                    )
                                }
                            }
                        }
                        BlockElementTypeSerializerState::InOutVariables(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BlockElementTypeSerializerState::OutputVariables(
                                        WithSerializer::serializer(
                                            &self.value.output_variables,
                                            Some("outputVariables"),
                                            false,
                                        )?,
                                    )
                                }
                            }
                        }
                        BlockElementTypeSerializerState::OutputVariables(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BlockElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        BlockElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = BlockElementTypeSerializerState::Documentation(
                                        IterSerializer::new(
                                            self.value.documentation.as_ref(),
                                            Some("documentation"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        BlockElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = BlockElementTypeSerializerState::End__,
                            }
                        }
                        BlockElementTypeSerializerState::End__ => {
                            *self.state = BlockElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        BlockElementTypeSerializerState::Done__ => return Ok(None),
                        BlockElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for BlockElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = BlockElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct InVariableElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::InVariableElementType,
            pub(super) state: Box<InVariableElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum InVariableElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointOut(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointOutType>,
                    super::ConnectionPointOutType,
                >,
            ),
            Expression(<::std::string::String as WithSerializer>::Serializer<'ser>),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> InVariableElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        InVariableElementTypeSerializerState::Init__ => {
                            *self.state = InVariableElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib_opt(
                                &mut bytes,
                                "executionOrderId",
                                &self.value.execution_order_id,
                            )?;
                            write_attrib(&mut bytes, "negated", &self.value.negated)?;
                            write_attrib(&mut bytes, "edge", &self.value.edge)?;
                            write_attrib(&mut bytes, "storage", &self.value.storage)?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        InVariableElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        InVariableElementTypeSerializerState::ConnectionPointOut(
                                            IterSerializer::new(
                                                self.value.connection_point_out.as_ref(),
                                                Some("connectionPointOut"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        InVariableElementTypeSerializerState::ConnectionPointOut(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = InVariableElementTypeSerializerState::Expression(
                                        WithSerializer::serializer(
                                            &self.value.expression,
                                            Some("expression"),
                                            false,
                                        )?,
                                    )
                                }
                            }
                        }
                        InVariableElementTypeSerializerState::Expression(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = InVariableElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        InVariableElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        InVariableElementTypeSerializerState::Documentation(
                                            IterSerializer::new(
                                                self.value.documentation.as_ref(),
                                                Some("documentation"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        InVariableElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = InVariableElementTypeSerializerState::End__,
                            }
                        }
                        InVariableElementTypeSerializerState::End__ => {
                            *self.state = InVariableElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        InVariableElementTypeSerializerState::Done__ => return Ok(None),
                        InVariableElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for InVariableElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = InVariableElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct OutVariableElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::OutVariableElementType,
            pub(super) state: Box<OutVariableElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum OutVariableElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointIn(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointInType>,
                    super::ConnectionPointInType,
                >,
            ),
            Expression(<::std::string::String as WithSerializer>::Serializer<'ser>),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> OutVariableElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        OutVariableElementTypeSerializerState::Init__ => {
                            *self.state = OutVariableElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib_opt(
                                &mut bytes,
                                "executionOrderId",
                                &self.value.execution_order_id,
                            )?;
                            write_attrib(&mut bytes, "negated", &self.value.negated)?;
                            write_attrib(&mut bytes, "edge", &self.value.edge)?;
                            write_attrib(&mut bytes, "storage", &self.value.storage)?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        OutVariableElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        OutVariableElementTypeSerializerState::ConnectionPointIn(
                                            IterSerializer::new(
                                                self.value.connection_point_in.as_ref(),
                                                Some("connectionPointIn"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        OutVariableElementTypeSerializerState::ConnectionPointIn(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = OutVariableElementTypeSerializerState::Expression(
                                        WithSerializer::serializer(
                                            &self.value.expression,
                                            Some("expression"),
                                            false,
                                        )?,
                                    )
                                }
                            }
                        }
                        OutVariableElementTypeSerializerState::Expression(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = OutVariableElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        OutVariableElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        OutVariableElementTypeSerializerState::Documentation(
                                            IterSerializer::new(
                                                self.value.documentation.as_ref(),
                                                Some("documentation"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        OutVariableElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = OutVariableElementTypeSerializerState::End__,
                            }
                        }
                        OutVariableElementTypeSerializerState::End__ => {
                            *self.state = OutVariableElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        OutVariableElementTypeSerializerState::Done__ => return Ok(None),
                        OutVariableElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for OutVariableElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = OutVariableElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct InOutVariableElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::InOutVariableElementType,
            pub(super) state: Box<InOutVariableElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum InOutVariableElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointIn(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointInType>,
                    super::ConnectionPointInType,
                >,
            ),
            ConnectionPointOut(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointOutType>,
                    super::ConnectionPointOutType,
                >,
            ),
            Expression(<::std::string::String as WithSerializer>::Serializer<'ser>),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> InOutVariableElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        InOutVariableElementTypeSerializerState::Init__ => {
                            *self.state = InOutVariableElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib_opt(
                                &mut bytes,
                                "executionOrderId",
                                &self.value.execution_order_id,
                            )?;
                            write_attrib(&mut bytes, "negatedIn", &self.value.negated_in)?;
                            write_attrib(&mut bytes, "edgeIn", &self.value.edge_in)?;
                            write_attrib(&mut bytes, "storageIn", &self.value.storage_in)?;
                            write_attrib(&mut bytes, "negatedOut", &self.value.negated_out)?;
                            write_attrib(&mut bytes, "edgeOut", &self.value.edge_out)?;
                            write_attrib(&mut bytes, "storageOut", &self.value.storage_out)?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        InOutVariableElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        InOutVariableElementTypeSerializerState::ConnectionPointIn(
                                            IterSerializer::new(
                                                self.value.connection_point_in.as_ref(),
                                                Some("connectionPointIn"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        InOutVariableElementTypeSerializerState::ConnectionPointIn(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        InOutVariableElementTypeSerializerState::ConnectionPointOut(
                                            IterSerializer::new(
                                                self.value.connection_point_out.as_ref(),
                                                Some("connectionPointOut"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        InOutVariableElementTypeSerializerState::ConnectionPointOut(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        InOutVariableElementTypeSerializerState::Expression(
                                            WithSerializer::serializer(
                                                &self.value.expression,
                                                Some("expression"),
                                                false,
                                            )?,
                                        )
                                }
                            }
                        }
                        InOutVariableElementTypeSerializerState::Expression(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = InOutVariableElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        InOutVariableElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        InOutVariableElementTypeSerializerState::Documentation(
                                            IterSerializer::new(
                                                self.value.documentation.as_ref(),
                                                Some("documentation"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        InOutVariableElementTypeSerializerState::Documentation(x) => match x
                            .next()
                            .transpose()?
                        {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = InOutVariableElementTypeSerializerState::End__,
                        },
                        InOutVariableElementTypeSerializerState::End__ => {
                            *self.state = InOutVariableElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        InOutVariableElementTypeSerializerState::Done__ => return Ok(None),
                        InOutVariableElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for InOutVariableElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = InOutVariableElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct LabelElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::LabelElementType,
            pub(super) state: Box<LabelElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum LabelElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> LabelElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        LabelElementTypeSerializerState::Init__ => {
                            *self.state = LabelElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib(&mut bytes, "label", &self.value.label)?;
                            write_attrib_opt(
                                &mut bytes,
                                "executionOrderId",
                                &self.value.execution_order_id,
                            )?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        LabelElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = LabelElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        LabelElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = LabelElementTypeSerializerState::Documentation(
                                        IterSerializer::new(
                                            self.value.documentation.as_ref(),
                                            Some("documentation"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        LabelElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = LabelElementTypeSerializerState::End__,
                            }
                        }
                        LabelElementTypeSerializerState::End__ => {
                            *self.state = LabelElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        LabelElementTypeSerializerState::Done__ => return Ok(None),
                        LabelElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for LabelElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = LabelElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct JumpElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::JumpElementType,
            pub(super) state: Box<JumpElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum JumpElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointIn(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointInType>,
                    super::ConnectionPointInType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> JumpElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        JumpElementTypeSerializerState::Init__ => {
                            *self.state = JumpElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib(&mut bytes, "label", &self.value.label)?;
                            write_attrib_opt(
                                &mut bytes,
                                "executionOrderId",
                                &self.value.execution_order_id,
                            )?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        JumpElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = JumpElementTypeSerializerState::ConnectionPointIn(
                                        IterSerializer::new(
                                            self.value.connection_point_in.as_ref(),
                                            Some("connectionPointIn"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        JumpElementTypeSerializerState::ConnectionPointIn(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = JumpElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        JumpElementTypeSerializerState::AddData(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = JumpElementTypeSerializerState::Documentation(
                                    IterSerializer::new(
                                        self.value.documentation.as_ref(),
                                        Some("documentation"),
                                        false,
                                    ),
                                )
                            }
                        },
                        JumpElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = JumpElementTypeSerializerState::End__,
                            }
                        }
                        JumpElementTypeSerializerState::End__ => {
                            *self.state = JumpElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        JumpElementTypeSerializerState::Done__ => return Ok(None),
                        JumpElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for JumpElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = JumpElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ReturnElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ReturnElementType,
            pub(super) state: Box<ReturnElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ReturnElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointIn(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointInType>,
                    super::ConnectionPointInType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ReturnElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ReturnElementTypeSerializerState::Init__ => {
                            *self.state = ReturnElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib_opt(
                                &mut bytes,
                                "executionOrderId",
                                &self.value.execution_order_id,
                            )?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ReturnElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ReturnElementTypeSerializerState::ConnectionPointIn(
                                            IterSerializer::new(
                                                self.value.connection_point_in.as_ref(),
                                                Some("connectionPointIn"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        ReturnElementTypeSerializerState::ConnectionPointIn(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = ReturnElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        ReturnElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = ReturnElementTypeSerializerState::Documentation(
                                        IterSerializer::new(
                                            self.value.documentation.as_ref(),
                                            Some("documentation"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        ReturnElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = ReturnElementTypeSerializerState::End__,
                            }
                        }
                        ReturnElementTypeSerializerState::End__ => {
                            *self.state = ReturnElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ReturnElementTypeSerializerState::Done__ => return Ok(None),
                        ReturnElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ReturnElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ReturnElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct LeftPowerRailElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::LeftPowerRailElementType,
            pub(super) state: Box<LeftPowerRailElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum LeftPowerRailElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointOut(
                IterSerializer<
                    'ser,
                    &'ser [super::LeftPowerRailConnectionPointOutElementType],
                    super::LeftPowerRailConnectionPointOutElementType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> LeftPowerRailElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        LeftPowerRailElementTypeSerializerState::Init__ => {
                            *self.state = LeftPowerRailElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib_opt(
                                &mut bytes,
                                "executionOrderId",
                                &self.value.execution_order_id,
                            )?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        LeftPowerRailElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        LeftPowerRailElementTypeSerializerState::ConnectionPointOut(
                                            IterSerializer::new(
                                                &self.value.connection_point_out[..],
                                                Some("connectionPointOut"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        LeftPowerRailElementTypeSerializerState::ConnectionPointOut(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = LeftPowerRailElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        LeftPowerRailElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        LeftPowerRailElementTypeSerializerState::Documentation(
                                            IterSerializer::new(
                                                self.value.documentation.as_ref(),
                                                Some("documentation"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        LeftPowerRailElementTypeSerializerState::Documentation(x) => match x
                            .next()
                            .transpose()?
                        {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = LeftPowerRailElementTypeSerializerState::End__,
                        },
                        LeftPowerRailElementTypeSerializerState::End__ => {
                            *self.state = LeftPowerRailElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        LeftPowerRailElementTypeSerializerState::Done__ => return Ok(None),
                        LeftPowerRailElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for LeftPowerRailElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = LeftPowerRailElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct RightPowerRailElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::RightPowerRailElementType,
            pub(super) state: Box<RightPowerRailElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum RightPowerRailElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointIn(
                IterSerializer<
                    'ser,
                    &'ser [super::ConnectionPointInType],
                    super::ConnectionPointInType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> RightPowerRailElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        RightPowerRailElementTypeSerializerState::Init__ => {
                            *self.state = RightPowerRailElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib_opt(
                                &mut bytes,
                                "executionOrderId",
                                &self.value.execution_order_id,
                            )?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        RightPowerRailElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        RightPowerRailElementTypeSerializerState::ConnectionPointIn(
                                            IterSerializer::new(
                                                &self.value.connection_point_in[..],
                                                Some("connectionPointIn"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        RightPowerRailElementTypeSerializerState::ConnectionPointIn(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = RightPowerRailElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        RightPowerRailElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        RightPowerRailElementTypeSerializerState::Documentation(
                                            IterSerializer::new(
                                                self.value.documentation.as_ref(),
                                                Some("documentation"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        RightPowerRailElementTypeSerializerState::Documentation(x) => match x
                            .next()
                            .transpose()?
                        {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = RightPowerRailElementTypeSerializerState::End__,
                        },
                        RightPowerRailElementTypeSerializerState::End__ => {
                            *self.state = RightPowerRailElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        RightPowerRailElementTypeSerializerState::Done__ => return Ok(None),
                        RightPowerRailElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for RightPowerRailElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = RightPowerRailElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct CoilElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::CoilElementType,
            pub(super) state: Box<CoilElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum CoilElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointIn(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointInType>,
                    super::ConnectionPointInType,
                >,
            ),
            ConnectionPointOut(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointOutType>,
                    super::ConnectionPointOutType,
                >,
            ),
            Variable(<::std::string::String as WithSerializer>::Serializer<'ser>),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> CoilElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        CoilElementTypeSerializerState::Init__ => {
                            *self.state = CoilElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib_opt(
                                &mut bytes,
                                "executionOrderId",
                                &self.value.execution_order_id,
                            )?;
                            write_attrib(&mut bytes, "negated", &self.value.negated)?;
                            write_attrib(&mut bytes, "edge", &self.value.edge)?;
                            write_attrib(&mut bytes, "storage", &self.value.storage)?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        CoilElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = CoilElementTypeSerializerState::ConnectionPointIn(
                                        IterSerializer::new(
                                            self.value.connection_point_in.as_ref(),
                                            Some("connectionPointIn"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        CoilElementTypeSerializerState::ConnectionPointIn(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = CoilElementTypeSerializerState::ConnectionPointOut(
                                        IterSerializer::new(
                                            self.value.connection_point_out.as_ref(),
                                            Some("connectionPointOut"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        CoilElementTypeSerializerState::ConnectionPointOut(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = CoilElementTypeSerializerState::Variable(
                                        WithSerializer::serializer(
                                            &self.value.variable,
                                            Some("variable"),
                                            false,
                                        )?,
                                    )
                                }
                            }
                        }
                        CoilElementTypeSerializerState::Variable(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = CoilElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        CoilElementTypeSerializerState::AddData(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = CoilElementTypeSerializerState::Documentation(
                                    IterSerializer::new(
                                        self.value.documentation.as_ref(),
                                        Some("documentation"),
                                        false,
                                    ),
                                )
                            }
                        },
                        CoilElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = CoilElementTypeSerializerState::End__,
                            }
                        }
                        CoilElementTypeSerializerState::End__ => {
                            *self.state = CoilElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        CoilElementTypeSerializerState::Done__ => return Ok(None),
                        CoilElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for CoilElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = CoilElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct StepElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::StepElementType,
            pub(super) state: Box<StepElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum StepElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointIn(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointInType>,
                    super::ConnectionPointInType,
                >,
            ),
            ConnectionPointOut(
                IterSerializer<
                    'ser,
                    Option<&'ser super::LeftPowerRailConnectionPointOutElementType>,
                    super::LeftPowerRailConnectionPointOutElementType,
                >,
            ),
            ConnectionPointOutAction(
                IterSerializer<
                    'ser,
                    Option<&'ser super::LeftPowerRailConnectionPointOutElementType>,
                    super::LeftPowerRailConnectionPointOutElementType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> StepElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        StepElementTypeSerializerState::Init__ => {
                            *self.state = StepElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib(&mut bytes, "name", &self.value.name)?;
                            write_attrib(&mut bytes, "initialStep", &self.value.initial_step)?;
                            write_attrib(&mut bytes, "negated", &self.value.negated)?;
                            write_attrib_opt(
                                &mut bytes,
                                "executionOrderId",
                                &self.value.execution_order_id,
                            )?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        StepElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = StepElementTypeSerializerState::ConnectionPointIn(
                                        IterSerializer::new(
                                            self.value.connection_point_in.as_ref(),
                                            Some("connectionPointIn"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        StepElementTypeSerializerState::ConnectionPointIn(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = StepElementTypeSerializerState::ConnectionPointOut(
                                        IterSerializer::new(
                                            self.value.connection_point_out.as_ref(),
                                            Some("connectionPointOut"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        StepElementTypeSerializerState::ConnectionPointOut(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        StepElementTypeSerializerState::ConnectionPointOutAction(
                                            IterSerializer::new(
                                                self.value.connection_point_out_action.as_ref(),
                                                Some("connectionPointOutAction"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        StepElementTypeSerializerState::ConnectionPointOutAction(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = StepElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        StepElementTypeSerializerState::AddData(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = StepElementTypeSerializerState::Documentation(
                                    IterSerializer::new(
                                        self.value.documentation.as_ref(),
                                        Some("documentation"),
                                        false,
                                    ),
                                )
                            }
                        },
                        StepElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = StepElementTypeSerializerState::End__,
                            }
                        }
                        StepElementTypeSerializerState::End__ => {
                            *self.state = StepElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        StepElementTypeSerializerState::Done__ => return Ok(None),
                        StepElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for StepElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = StepElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct MacroStepElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::MacroStepElementType,
            pub(super) state: Box<MacroStepElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum MacroStepElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointIn(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointInType>,
                    super::ConnectionPointInType,
                >,
            ),
            ConnectionPointOut(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointOutType>,
                    super::ConnectionPointOutType,
                >,
            ),
            Body(IterSerializer<'ser, Option<&'ser super::BodyType>, super::BodyType>),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> MacroStepElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        MacroStepElementTypeSerializerState::Init__ => {
                            *self.state = MacroStepElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib_opt(&mut bytes, "name", &self.value.name)?;
                            write_attrib_opt(
                                &mut bytes,
                                "executionOrderId",
                                &self.value.execution_order_id,
                            )?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        MacroStepElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        MacroStepElementTypeSerializerState::ConnectionPointIn(
                                            IterSerializer::new(
                                                self.value.connection_point_in.as_ref(),
                                                Some("connectionPointIn"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        MacroStepElementTypeSerializerState::ConnectionPointIn(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        MacroStepElementTypeSerializerState::ConnectionPointOut(
                                            IterSerializer::new(
                                                self.value.connection_point_out.as_ref(),
                                                Some("connectionPointOut"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        MacroStepElementTypeSerializerState::ConnectionPointOut(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = MacroStepElementTypeSerializerState::Body(
                                        IterSerializer::new(
                                            self.value.body.as_ref(),
                                            Some("body"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        MacroStepElementTypeSerializerState::Body(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = MacroStepElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        MacroStepElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = MacroStepElementTypeSerializerState::Documentation(
                                        IterSerializer::new(
                                            self.value.documentation.as_ref(),
                                            Some("documentation"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        MacroStepElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = MacroStepElementTypeSerializerState::End__,
                            }
                        }
                        MacroStepElementTypeSerializerState::End__ => {
                            *self.state = MacroStepElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        MacroStepElementTypeSerializerState::Done__ => return Ok(None),
                        MacroStepElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for MacroStepElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = MacroStepElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct JumpStepElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::JumpStepElementType,
            pub(super) state: Box<JumpStepElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum JumpStepElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointIn(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointInType>,
                    super::ConnectionPointInType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> JumpStepElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        JumpStepElementTypeSerializerState::Init__ => {
                            *self.state = JumpStepElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib(&mut bytes, "targetName", &self.value.target_name)?;
                            write_attrib_opt(
                                &mut bytes,
                                "executionOrderId",
                                &self.value.execution_order_id,
                            )?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        JumpStepElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        JumpStepElementTypeSerializerState::ConnectionPointIn(
                                            IterSerializer::new(
                                                self.value.connection_point_in.as_ref(),
                                                Some("connectionPointIn"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        JumpStepElementTypeSerializerState::ConnectionPointIn(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = JumpStepElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        JumpStepElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = JumpStepElementTypeSerializerState::Documentation(
                                        IterSerializer::new(
                                            self.value.documentation.as_ref(),
                                            Some("documentation"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        JumpStepElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = JumpStepElementTypeSerializerState::End__,
                            }
                        }
                        JumpStepElementTypeSerializerState::End__ => {
                            *self.state = JumpStepElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        JumpStepElementTypeSerializerState::Done__ => return Ok(None),
                        JumpStepElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for JumpStepElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = JumpStepElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct TransitionElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::TransitionElementType,
            pub(super) state: Box<TransitionElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum TransitionElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointIn(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointInType>,
                    super::ConnectionPointInType,
                >,
            ),
            ConnectionPointOut(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointOutType>,
                    super::ConnectionPointOutType,
                >,
            ),
            Condition(
                IterSerializer<
                    'ser,
                    Option<&'ser super::TransitionConditionElementType>,
                    super::TransitionConditionElementType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> TransitionElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        TransitionElementTypeSerializerState::Init__ => {
                            *self.state = TransitionElementTypeSerializerState::Position(
                                WithSerializer::serializer(
                                    &self.value.position,
                                    Some("position"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib_opt(&mut bytes, "priority", &self.value.priority)?;
                            write_attrib_opt(
                                &mut bytes,
                                "executionOrderId",
                                &self.value.execution_order_id,
                            )?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        TransitionElementTypeSerializerState::Position(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        TransitionElementTypeSerializerState::ConnectionPointIn(
                                            IterSerializer::new(
                                                self.value.connection_point_in.as_ref(),
                                                Some("connectionPointIn"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        TransitionElementTypeSerializerState::ConnectionPointIn(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        TransitionElementTypeSerializerState::ConnectionPointOut(
                                            IterSerializer::new(
                                                self.value.connection_point_out.as_ref(),
                                                Some("connectionPointOut"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        TransitionElementTypeSerializerState::ConnectionPointOut(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = TransitionElementTypeSerializerState::Condition(
                                        IterSerializer::new(
                                            self.value.condition.as_ref(),
                                            Some("condition"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        TransitionElementTypeSerializerState::Condition(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = TransitionElementTypeSerializerState::AddData(
                                        IterSerializer::new(
                                            self.value.add_data.as_ref(),
                                            Some("addData"),
                                            false,
                                        ),
                                    )
                                }
                            }
                        }
                        TransitionElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        TransitionElementTypeSerializerState::Documentation(
                                            IterSerializer::new(
                                                self.value.documentation.as_ref(),
                                                Some("documentation"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        TransitionElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = TransitionElementTypeSerializerState::End__,
                            }
                        }
                        TransitionElementTypeSerializerState::End__ => {
                            *self.state = TransitionElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        TransitionElementTypeSerializerState::Done__ => return Ok(None),
                        TransitionElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for TransitionElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = TransitionElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct SelectionDivergenceElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::SelectionDivergenceElementType,
            pub(super) state: Box<SelectionDivergenceElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum SelectionDivergenceElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointIn(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointInType>,
                    super::ConnectionPointInType,
                >,
            ),
            ConnectionPointOut(
                IterSerializer<
                    'ser,
                    &'ser [super::LeftPowerRailConnectionPointOutElementType],
                    super::LeftPowerRailConnectionPointOutElementType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> SelectionDivergenceElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { SelectionDivergenceElementTypeSerializerState :: Init__ => { * self . state = SelectionDivergenceElementTypeSerializerState :: Position (WithSerializer :: serializer (& self . value . position , Some ("position") , false) ?) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } write_attrib (& mut bytes , "localId" , & self . value . local_id) ? ; write_attrib_opt (& mut bytes , "height" , & self . value . height) ? ; write_attrib_opt (& mut bytes , "width" , & self . value . width) ? ; write_attrib_opt (& mut bytes , "globalId" , & self . value . global_id) ? ; return Ok (Some (Event :: Start (bytes))) } SelectionDivergenceElementTypeSerializerState :: Position (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SelectionDivergenceElementTypeSerializerState :: ConnectionPointIn (IterSerializer :: new (self . value . connection_point_in . as_ref () , Some ("connectionPointIn") , false)) , } SelectionDivergenceElementTypeSerializerState :: ConnectionPointIn (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SelectionDivergenceElementTypeSerializerState :: ConnectionPointOut (IterSerializer :: new (& self . value . connection_point_out [..] , Some ("connectionPointOut") , false)) , } SelectionDivergenceElementTypeSerializerState :: ConnectionPointOut (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SelectionDivergenceElementTypeSerializerState :: AddData (IterSerializer :: new (self . value . add_data . as_ref () , Some ("addData") , false)) , } SelectionDivergenceElementTypeSerializerState :: AddData (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SelectionDivergenceElementTypeSerializerState :: Documentation (IterSerializer :: new (self . value . documentation . as_ref () , Some ("documentation") , false)) , } SelectionDivergenceElementTypeSerializerState :: Documentation (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SelectionDivergenceElementTypeSerializerState :: End__ , } SelectionDivergenceElementTypeSerializerState :: End__ => { * self . state = SelectionDivergenceElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } SelectionDivergenceElementTypeSerializerState :: Done__ => return Ok (None) , SelectionDivergenceElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for SelectionDivergenceElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = SelectionDivergenceElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct SelectionConvergenceElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::SelectionConvergenceElementType,
            pub(super) state: Box<SelectionConvergenceElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum SelectionConvergenceElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointIn(
                IterSerializer<
                    'ser,
                    &'ser [super::SelectionConvergenceConnectionPointInElementType],
                    super::SelectionConvergenceConnectionPointInElementType,
                >,
            ),
            ConnectionPointOut(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointOutType>,
                    super::ConnectionPointOutType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> SelectionConvergenceElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { SelectionConvergenceElementTypeSerializerState :: Init__ => { * self . state = SelectionConvergenceElementTypeSerializerState :: Position (WithSerializer :: serializer (& self . value . position , Some ("position") , false) ?) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } write_attrib (& mut bytes , "localId" , & self . value . local_id) ? ; write_attrib_opt (& mut bytes , "height" , & self . value . height) ? ; write_attrib_opt (& mut bytes , "width" , & self . value . width) ? ; write_attrib_opt (& mut bytes , "globalId" , & self . value . global_id) ? ; return Ok (Some (Event :: Start (bytes))) } SelectionConvergenceElementTypeSerializerState :: Position (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SelectionConvergenceElementTypeSerializerState :: ConnectionPointIn (IterSerializer :: new (& self . value . connection_point_in [..] , Some ("connectionPointIn") , false)) , } SelectionConvergenceElementTypeSerializerState :: ConnectionPointIn (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SelectionConvergenceElementTypeSerializerState :: ConnectionPointOut (IterSerializer :: new (self . value . connection_point_out . as_ref () , Some ("connectionPointOut") , false)) , } SelectionConvergenceElementTypeSerializerState :: ConnectionPointOut (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SelectionConvergenceElementTypeSerializerState :: AddData (IterSerializer :: new (self . value . add_data . as_ref () , Some ("addData") , false)) , } SelectionConvergenceElementTypeSerializerState :: AddData (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SelectionConvergenceElementTypeSerializerState :: Documentation (IterSerializer :: new (self . value . documentation . as_ref () , Some ("documentation") , false)) , } SelectionConvergenceElementTypeSerializerState :: Documentation (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SelectionConvergenceElementTypeSerializerState :: End__ , } SelectionConvergenceElementTypeSerializerState :: End__ => { * self . state = SelectionConvergenceElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } SelectionConvergenceElementTypeSerializerState :: Done__ => return Ok (None) , SelectionConvergenceElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for SelectionConvergenceElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = SelectionConvergenceElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct SimultaneousDivergenceElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::SimultaneousDivergenceElementType,
            pub(super) state: Box<SimultaneousDivergenceElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum SimultaneousDivergenceElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointIn(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointInType>,
                    super::ConnectionPointInType,
                >,
            ),
            ConnectionPointOut(
                IterSerializer<
                    'ser,
                    &'ser [super::LeftPowerRailConnectionPointOutElementType],
                    super::LeftPowerRailConnectionPointOutElementType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> SimultaneousDivergenceElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { SimultaneousDivergenceElementTypeSerializerState :: Init__ => { * self . state = SimultaneousDivergenceElementTypeSerializerState :: Position (WithSerializer :: serializer (& self . value . position , Some ("position") , false) ?) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } write_attrib (& mut bytes , "localId" , & self . value . local_id) ? ; write_attrib_opt (& mut bytes , "height" , & self . value . height) ? ; write_attrib_opt (& mut bytes , "width" , & self . value . width) ? ; write_attrib_opt (& mut bytes , "name" , & self . value . name) ? ; write_attrib_opt (& mut bytes , "globalId" , & self . value . global_id) ? ; return Ok (Some (Event :: Start (bytes))) } SimultaneousDivergenceElementTypeSerializerState :: Position (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SimultaneousDivergenceElementTypeSerializerState :: ConnectionPointIn (IterSerializer :: new (self . value . connection_point_in . as_ref () , Some ("connectionPointIn") , false)) , } SimultaneousDivergenceElementTypeSerializerState :: ConnectionPointIn (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SimultaneousDivergenceElementTypeSerializerState :: ConnectionPointOut (IterSerializer :: new (& self . value . connection_point_out [..] , Some ("connectionPointOut") , false)) , } SimultaneousDivergenceElementTypeSerializerState :: ConnectionPointOut (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SimultaneousDivergenceElementTypeSerializerState :: AddData (IterSerializer :: new (self . value . add_data . as_ref () , Some ("addData") , false)) , } SimultaneousDivergenceElementTypeSerializerState :: AddData (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SimultaneousDivergenceElementTypeSerializerState :: Documentation (IterSerializer :: new (self . value . documentation . as_ref () , Some ("documentation") , false)) , } SimultaneousDivergenceElementTypeSerializerState :: Documentation (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SimultaneousDivergenceElementTypeSerializerState :: End__ , } SimultaneousDivergenceElementTypeSerializerState :: End__ => { * self . state = SimultaneousDivergenceElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } SimultaneousDivergenceElementTypeSerializerState :: Done__ => return Ok (None) , SimultaneousDivergenceElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for SimultaneousDivergenceElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = SimultaneousDivergenceElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct SimultaneousConvergenceElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::SimultaneousConvergenceElementType,
            pub(super) state: Box<SimultaneousConvergenceElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum SimultaneousConvergenceElementTypeSerializerState<'ser> {
            Init__,
            Position(<super::PositionType as WithSerializer>::Serializer<'ser>),
            ConnectionPointIn(
                IterSerializer<
                    'ser,
                    &'ser [super::ConnectionPointInType],
                    super::ConnectionPointInType,
                >,
            ),
            ConnectionPointOut(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointOutType>,
                    super::ConnectionPointOutType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> SimultaneousConvergenceElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { SimultaneousConvergenceElementTypeSerializerState :: Init__ => { * self . state = SimultaneousConvergenceElementTypeSerializerState :: Position (WithSerializer :: serializer (& self . value . position , Some ("position") , false) ?) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } write_attrib (& mut bytes , "localId" , & self . value . local_id) ? ; write_attrib_opt (& mut bytes , "height" , & self . value . height) ? ; write_attrib_opt (& mut bytes , "width" , & self . value . width) ? ; write_attrib_opt (& mut bytes , "globalId" , & self . value . global_id) ? ; return Ok (Some (Event :: Start (bytes))) } SimultaneousConvergenceElementTypeSerializerState :: Position (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SimultaneousConvergenceElementTypeSerializerState :: ConnectionPointIn (IterSerializer :: new (& self . value . connection_point_in [..] , Some ("connectionPointIn") , false)) , } SimultaneousConvergenceElementTypeSerializerState :: ConnectionPointIn (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SimultaneousConvergenceElementTypeSerializerState :: ConnectionPointOut (IterSerializer :: new (self . value . connection_point_out . as_ref () , Some ("connectionPointOut") , false)) , } SimultaneousConvergenceElementTypeSerializerState :: ConnectionPointOut (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SimultaneousConvergenceElementTypeSerializerState :: AddData (IterSerializer :: new (self . value . add_data . as_ref () , Some ("addData") , false)) , } SimultaneousConvergenceElementTypeSerializerState :: AddData (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SimultaneousConvergenceElementTypeSerializerState :: Documentation (IterSerializer :: new (self . value . documentation . as_ref () , Some ("documentation") , false)) , } SimultaneousConvergenceElementTypeSerializerState :: Documentation (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SimultaneousConvergenceElementTypeSerializerState :: End__ , } SimultaneousConvergenceElementTypeSerializerState :: End__ => { * self . state = SimultaneousConvergenceElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } SimultaneousConvergenceElementTypeSerializerState :: Done__ => return Ok (None) , SimultaneousConvergenceElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for SimultaneousConvergenceElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = SimultaneousConvergenceElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct EnumValuesElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::EnumValuesElementType,
            pub(super) state: Box<EnumValuesElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum EnumValuesElementTypeSerializerState<'ser> {
            Init__,
            Content__(
                IterSerializer<
                    'ser,
                    &'ser [super::EnumValuesElementTypeContent],
                    super::EnumValuesElementTypeContent,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> EnumValuesElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        EnumValuesElementTypeSerializerState::Init__ => {
                            *self.state = EnumValuesElementTypeSerializerState::Content__(
                                IterSerializer::new(&self.value.content[..], None, false),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        EnumValuesElementTypeSerializerState::Content__(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state = EnumValuesElementTypeSerializerState::End__,
                            }
                        }
                        EnumValuesElementTypeSerializerState::End__ => {
                            *self.state = EnumValuesElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        EnumValuesElementTypeSerializerState::Done__ => return Ok(None),
                        EnumValuesElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for EnumValuesElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = EnumValuesElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct EnumValuesElementTypeContentSerializer<'ser> {
            pub(super) value: &'ser super::EnumValuesElementTypeContent,
            pub(super) state: Box<EnumValuesElementTypeContentSerializerState<'ser>>,
        }
        #[derive(Debug)]
        pub(super) enum EnumValuesElementTypeContentSerializerState<'ser> {
            Init__,
            Value(<super::EnumValuesValueElementType as WithSerializer>::Serializer<'ser>),
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> EnumValuesElementTypeContentSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        EnumValuesElementTypeContentSerializerState::Init__ => {
                            *self.state = EnumValuesElementTypeContentSerializerState::Value(
                                WithSerializer::serializer(
                                    &self.value.value,
                                    Some("value"),
                                    false,
                                )?,
                            );
                        }
                        EnumValuesElementTypeContentSerializerState::Value(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        EnumValuesElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        EnumValuesElementTypeContentSerializerState::Done__ => return Ok(None),
                        EnumValuesElementTypeContentSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for EnumValuesElementTypeContentSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = EnumValuesElementTypeContentSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectContentHeaderCoordinateInfoElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectContentHeaderCoordinateInfoElementType,
            pub(super) state:
                Box<ProjectContentHeaderCoordinateInfoElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectContentHeaderCoordinateInfoElementTypeSerializerState<'ser> {
            Init__ , PageSize (IterSerializer < 'ser , Option < & 'ser super :: PositionType > , super :: PositionType >) , Fbd (< super :: ProjectContentHeaderCoordinateInfoFbdElementType as WithSerializer > :: Serializer < 'ser >) , Ld (< super :: ProjectContentHeaderCoordinateInfoFbdElementType as WithSerializer > :: Serializer < 'ser >) , Sfc (< super :: ProjectContentHeaderCoordinateInfoFbdElementType as WithSerializer > :: Serializer < 'ser >) , End__ , Done__ , Phantom__ (& 'ser ()) , }
        impl<'ser> ProjectContentHeaderCoordinateInfoElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { ProjectContentHeaderCoordinateInfoElementTypeSerializerState :: Init__ => { * self . state = ProjectContentHeaderCoordinateInfoElementTypeSerializerState :: PageSize (IterSerializer :: new (self . value . page_size . as_ref () , Some ("pageSize") , false)) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } return Ok (Some (Event :: Start (bytes))) } ProjectContentHeaderCoordinateInfoElementTypeSerializerState :: PageSize (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectContentHeaderCoordinateInfoElementTypeSerializerState :: Fbd (WithSerializer :: serializer (& self . value . fbd , Some ("fbd") , false) ?) , } ProjectContentHeaderCoordinateInfoElementTypeSerializerState :: Fbd (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectContentHeaderCoordinateInfoElementTypeSerializerState :: Ld (WithSerializer :: serializer (& self . value . ld , Some ("ld") , false) ?) , } ProjectContentHeaderCoordinateInfoElementTypeSerializerState :: Ld (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectContentHeaderCoordinateInfoElementTypeSerializerState :: Sfc (WithSerializer :: serializer (& self . value . sfc , Some ("sfc") , false) ?) , } ProjectContentHeaderCoordinateInfoElementTypeSerializerState :: Sfc (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectContentHeaderCoordinateInfoElementTypeSerializerState :: End__ , } ProjectContentHeaderCoordinateInfoElementTypeSerializerState :: End__ => { * self . state = ProjectContentHeaderCoordinateInfoElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } ProjectContentHeaderCoordinateInfoElementTypeSerializerState :: Done__ => return Ok (None) , ProjectContentHeaderCoordinateInfoElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for ProjectContentHeaderCoordinateInfoElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state =
                            ProjectContentHeaderCoordinateInfoElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesDataTypesElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectTypesDataTypesElementType,
            pub(super) state: Box<ProjectTypesDataTypesElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectTypesDataTypesElementTypeSerializerState<'ser> {
            Init__,
            DataType(
                IterSerializer<
                    'ser,
                    &'ser [super::ProjectTypesDataTypesDataTypeElementType],
                    super::ProjectTypesDataTypesDataTypeElementType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ProjectTypesDataTypesElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ProjectTypesDataTypesElementTypeSerializerState::Init__ => {
                            *self.state = ProjectTypesDataTypesElementTypeSerializerState::DataType(
                                IterSerializer::new(
                                    &self.value.data_type[..],
                                    Some("dataType"),
                                    false,
                                ),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ProjectTypesDataTypesElementTypeSerializerState::DataType(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ProjectTypesDataTypesElementTypeSerializerState::End__
                                }
                            }
                        }
                        ProjectTypesDataTypesElementTypeSerializerState::End__ => {
                            *self.state = ProjectTypesDataTypesElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ProjectTypesDataTypesElementTypeSerializerState::Done__ => return Ok(None),
                        ProjectTypesDataTypesElementTypeSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for ProjectTypesDataTypesElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ProjectTypesDataTypesElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesPousElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectTypesPousElementType,
            pub(super) state: Box<ProjectTypesPousElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectTypesPousElementTypeSerializerState<'ser> {
            Init__,
            Pou(
                IterSerializer<
                    'ser,
                    &'ser [super::ProjectTypesPousPouElementType],
                    super::ProjectTypesPousPouElementType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ProjectTypesPousElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ProjectTypesPousElementTypeSerializerState::Init__ => {
                            *self.state = ProjectTypesPousElementTypeSerializerState::Pou(
                                IterSerializer::new(&self.value.pou[..], Some("pou"), false),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ProjectTypesPousElementTypeSerializerState::Pou(x) => match x
                            .next()
                            .transpose()?
                        {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = ProjectTypesPousElementTypeSerializerState::End__,
                        },
                        ProjectTypesPousElementTypeSerializerState::End__ => {
                            *self.state = ProjectTypesPousElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ProjectTypesPousElementTypeSerializerState::Done__ => return Ok(None),
                        ProjectTypesPousElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ProjectTypesPousElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ProjectTypesPousElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectInstancesConfigurationsElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectInstancesConfigurationsElementType,
            pub(super) state: Box<ProjectInstancesConfigurationsElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectInstancesConfigurationsElementTypeSerializerState<'ser> {
            Init__,
            Configuration(
                IterSerializer<
                    'ser,
                    &'ser [super::ProjectInstancesConfigurationsConfigurationElementType],
                    super::ProjectInstancesConfigurationsConfigurationElementType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ProjectInstancesConfigurationsElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ProjectInstancesConfigurationsElementTypeSerializerState::Init__ => {
                            * self . state = ProjectInstancesConfigurationsElementTypeSerializerState :: Configuration (IterSerializer :: new (& self . value . configuration [..] , Some ("configuration") , false)) ;
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ProjectInstancesConfigurationsElementTypeSerializerState::Configuration(
                            x,
                        ) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state =
                                    ProjectInstancesConfigurationsElementTypeSerializerState::End__,
                            }
                        }
                        ProjectInstancesConfigurationsElementTypeSerializerState::End__ => {
                            *self.state =
                                ProjectInstancesConfigurationsElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ProjectInstancesConfigurationsElementTypeSerializerState::Done__ => {
                            return Ok(None)
                        }
                        ProjectInstancesConfigurationsElementTypeSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for ProjectInstancesConfigurationsElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state =
                            ProjectInstancesConfigurationsElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ValueArrayValueValueElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ValueArrayValueValueElementType,
            pub(super) state: Box<ValueArrayValueValueElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ValueArrayValueValueElementTypeSerializerState<'ser> {
            Init__,
            Content__(
                <super::ValueArrayValueValueElementTypeContent as WithSerializer>::Serializer<'ser>,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ValueArrayValueValueElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ValueArrayValueValueElementTypeSerializerState::Init__ => {
                            *self.state = ValueArrayValueValueElementTypeSerializerState::Content__(
                                WithSerializer::serializer(&self.value.content, None, false)?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(
                                &mut bytes,
                                "repetitionValue",
                                &self.value.repetition_value,
                            )?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ValueArrayValueValueElementTypeSerializerState::Content__(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ValueArrayValueValueElementTypeSerializerState::End__
                                }
                            }
                        }
                        ValueArrayValueValueElementTypeSerializerState::End__ => {
                            *self.state = ValueArrayValueValueElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ValueArrayValueValueElementTypeSerializerState::Done__ => return Ok(None),
                        ValueArrayValueValueElementTypeSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for ValueArrayValueValueElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ValueArrayValueValueElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ValueArrayValueValueElementTypeContentSerializer<'ser> {
            pub(super) value: &'ser super::ValueArrayValueValueElementTypeContent,
            pub(super) state: Box<ValueArrayValueValueElementTypeContentSerializerState<'ser>>,
        }
        #[derive(Debug)]
        pub(super) enum ValueArrayValueValueElementTypeContentSerializerState<'ser> {
            Init__,
            SimpleValue(<super::ValueSimpleValueElementType as WithSerializer>::Serializer<'ser>),
            ArrayValue(<super::ValueArrayValueElementType as WithSerializer>::Serializer<'ser>),
            StructValue(<super::ValueStructValueElementType as WithSerializer>::Serializer<'ser>),
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ValueArrayValueValueElementTypeContentSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { ValueArrayValueValueElementTypeContentSerializerState :: Init__ => { match self . value { super :: ValueArrayValueValueElementTypeContent :: SimpleValue (x) => * self . state = ValueArrayValueValueElementTypeContentSerializerState :: SimpleValue (WithSerializer :: serializer (x , Some ("simpleValue") , false) ?) , super :: ValueArrayValueValueElementTypeContent :: ArrayValue (x) => * self . state = ValueArrayValueValueElementTypeContentSerializerState :: ArrayValue (WithSerializer :: serializer (x , Some ("arrayValue") , false) ?) , super :: ValueArrayValueValueElementTypeContent :: StructValue (x) => * self . state = ValueArrayValueValueElementTypeContentSerializerState :: StructValue (WithSerializer :: serializer (x , Some ("structValue") , false) ?) , } } ValueArrayValueValueElementTypeContentSerializerState :: SimpleValue (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ValueArrayValueValueElementTypeContentSerializerState :: Done__ , } } ValueArrayValueValueElementTypeContentSerializerState :: ArrayValue (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ValueArrayValueValueElementTypeContentSerializerState :: Done__ , } } ValueArrayValueValueElementTypeContentSerializerState :: StructValue (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ValueArrayValueValueElementTypeContentSerializerState :: Done__ , } } ValueArrayValueValueElementTypeContentSerializerState :: Done__ => return Ok (None) , ValueArrayValueValueElementTypeContentSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for ValueArrayValueValueElementTypeContentSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ValueArrayValueValueElementTypeContentSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ValueStructValueValueElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ValueStructValueValueElementType,
            pub(super) state: Box<ValueStructValueValueElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ValueStructValueValueElementTypeSerializerState<'ser> {
            Init__,
            Content__(
                <super::ValueStructValueValueElementTypeContent as WithSerializer>::Serializer<
                    'ser,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ValueStructValueValueElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ValueStructValueValueElementTypeSerializerState::Init__ => {
                            *self.state =
                                ValueStructValueValueElementTypeSerializerState::Content__(
                                    WithSerializer::serializer(&self.value.content, None, false)?,
                                );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "member", &self.value.member)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ValueStructValueValueElementTypeSerializerState::Content__(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ValueStructValueValueElementTypeSerializerState::End__
                                }
                            }
                        }
                        ValueStructValueValueElementTypeSerializerState::End__ => {
                            *self.state = ValueStructValueValueElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ValueStructValueValueElementTypeSerializerState::Done__ => return Ok(None),
                        ValueStructValueValueElementTypeSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for ValueStructValueValueElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ValueStructValueValueElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ValueStructValueValueElementTypeContentSerializer<'ser> {
            pub(super) value: &'ser super::ValueStructValueValueElementTypeContent,
            pub(super) state: Box<ValueStructValueValueElementTypeContentSerializerState<'ser>>,
        }
        #[derive(Debug)]
        pub(super) enum ValueStructValueValueElementTypeContentSerializerState<'ser> {
            Init__,
            SimpleValue(<super::ValueSimpleValueElementType as WithSerializer>::Serializer<'ser>),
            ArrayValue(<super::ValueArrayValueElementType as WithSerializer>::Serializer<'ser>),
            StructValue(<super::ValueStructValueElementType as WithSerializer>::Serializer<'ser>),
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ValueStructValueValueElementTypeContentSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { ValueStructValueValueElementTypeContentSerializerState :: Init__ => { match self . value { super :: ValueStructValueValueElementTypeContent :: SimpleValue (x) => * self . state = ValueStructValueValueElementTypeContentSerializerState :: SimpleValue (WithSerializer :: serializer (x , Some ("simpleValue") , false) ?) , super :: ValueStructValueValueElementTypeContent :: ArrayValue (x) => * self . state = ValueStructValueValueElementTypeContentSerializerState :: ArrayValue (WithSerializer :: serializer (x , Some ("arrayValue") , false) ?) , super :: ValueStructValueValueElementTypeContent :: StructValue (x) => * self . state = ValueStructValueValueElementTypeContentSerializerState :: StructValue (WithSerializer :: serializer (x , Some ("structValue") , false) ?) , } } ValueStructValueValueElementTypeContentSerializerState :: SimpleValue (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ValueStructValueValueElementTypeContentSerializerState :: Done__ , } } ValueStructValueValueElementTypeContentSerializerState :: ArrayValue (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ValueStructValueValueElementTypeContentSerializerState :: Done__ , } } ValueStructValueValueElementTypeContentSerializerState :: StructValue (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ValueStructValueValueElementTypeContentSerializerState :: Done__ , } } ValueStructValueValueElementTypeContentSerializerState :: Done__ => return Ok (None) , ValueStructValueValueElementTypeContentSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for ValueStructValueValueElementTypeContentSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state =
                            ValueStructValueValueElementTypeContentSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ActionBlockActionElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ActionBlockActionElementType,
            pub(super) state: Box<ActionBlockActionElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ActionBlockActionElementTypeSerializerState<'ser> {
            Init__,
            RelPosition(<super::PositionType as WithSerializer>::Serializer<'ser>),
            Reference(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ActionBlockActionReferenceElementType>,
                    super::ActionBlockActionReferenceElementType,
                >,
            ),
            Inline(IterSerializer<'ser, Option<&'ser super::BodyType>, super::BodyType>),
            ConnectionPointOut(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointOutType>,
                    super::ConnectionPointOutType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ActionBlockActionElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ActionBlockActionElementTypeSerializerState::Init__ => {
                            *self.state = ActionBlockActionElementTypeSerializerState::RelPosition(
                                WithSerializer::serializer(
                                    &self.value.rel_position,
                                    Some("relPosition"),
                                    false,
                                )?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "localId", &self.value.local_id)?;
                            write_attrib(&mut bytes, "qualifier", &self.value.qualifier)?;
                            write_attrib_opt(&mut bytes, "width", &self.value.width)?;
                            write_attrib_opt(&mut bytes, "height", &self.value.height)?;
                            write_attrib_opt(&mut bytes, "duration", &self.value.duration)?;
                            write_attrib_opt(&mut bytes, "indicator", &self.value.indicator)?;
                            write_attrib_opt(
                                &mut bytes,
                                "executionOrderId",
                                &self.value.execution_order_id,
                            )?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ActionBlockActionElementTypeSerializerState::RelPosition(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ActionBlockActionElementTypeSerializerState::Reference(
                                            IterSerializer::new(
                                                self.value.reference.as_ref(),
                                                Some("reference"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        ActionBlockActionElementTypeSerializerState::Reference(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ActionBlockActionElementTypeSerializerState::Inline(
                                            IterSerializer::new(
                                                self.value.inline.as_ref(),
                                                Some("inline"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        ActionBlockActionElementTypeSerializerState::Inline(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state =
                                    ActionBlockActionElementTypeSerializerState::ConnectionPointOut(
                                        IterSerializer::new(
                                            self.value.connection_point_out.as_ref(),
                                            Some("connectionPointOut"),
                                            false,
                                        ),
                                    ),
                            }
                        }
                        ActionBlockActionElementTypeSerializerState::ConnectionPointOut(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ActionBlockActionElementTypeSerializerState::AddData(
                                            IterSerializer::new(
                                                self.value.add_data.as_ref(),
                                                Some("addData"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        ActionBlockActionElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ActionBlockActionElementTypeSerializerState::Documentation(
                                            IterSerializer::new(
                                                self.value.documentation.as_ref(),
                                                Some("documentation"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        ActionBlockActionElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state = ActionBlockActionElementTypeSerializerState::End__
                                }
                            }
                        }
                        ActionBlockActionElementTypeSerializerState::End__ => {
                            *self.state = ActionBlockActionElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ActionBlockActionElementTypeSerializerState::Done__ => return Ok(None),
                        ActionBlockActionElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for ActionBlockActionElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ActionBlockActionElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct BlockInputVariablesElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::BlockInputVariablesElementType,
            pub(super) state: Box<BlockInputVariablesElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum BlockInputVariablesElementTypeSerializerState<'ser> {
            Init__,
            Variable(
                IterSerializer<
                    'ser,
                    &'ser [super::BlockInputVariablesVariableElementType],
                    super::BlockInputVariablesVariableElementType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> BlockInputVariablesElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        BlockInputVariablesElementTypeSerializerState::Init__ => {
                            *self.state = BlockInputVariablesElementTypeSerializerState::Variable(
                                IterSerializer::new(
                                    &self.value.variable[..],
                                    Some("variable"),
                                    false,
                                ),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        BlockInputVariablesElementTypeSerializerState::Variable(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        BlockInputVariablesElementTypeSerializerState::End__
                                }
                            }
                        }
                        BlockInputVariablesElementTypeSerializerState::End__ => {
                            *self.state = BlockInputVariablesElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        BlockInputVariablesElementTypeSerializerState::Done__ => return Ok(None),
                        BlockInputVariablesElementTypeSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for BlockInputVariablesElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = BlockInputVariablesElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct BlockInOutVariablesElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::BlockInOutVariablesElementType,
            pub(super) state: Box<BlockInOutVariablesElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum BlockInOutVariablesElementTypeSerializerState<'ser> {
            Init__,
            Variable(
                IterSerializer<
                    'ser,
                    &'ser [super::BlockInOutVariablesVariableElementType],
                    super::BlockInOutVariablesVariableElementType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> BlockInOutVariablesElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        BlockInOutVariablesElementTypeSerializerState::Init__ => {
                            *self.state = BlockInOutVariablesElementTypeSerializerState::Variable(
                                IterSerializer::new(
                                    &self.value.variable[..],
                                    Some("variable"),
                                    false,
                                ),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        BlockInOutVariablesElementTypeSerializerState::Variable(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        BlockInOutVariablesElementTypeSerializerState::End__
                                }
                            }
                        }
                        BlockInOutVariablesElementTypeSerializerState::End__ => {
                            *self.state = BlockInOutVariablesElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        BlockInOutVariablesElementTypeSerializerState::Done__ => return Ok(None),
                        BlockInOutVariablesElementTypeSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for BlockInOutVariablesElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = BlockInOutVariablesElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct BlockOutputVariablesElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::BlockOutputVariablesElementType,
            pub(super) state: Box<BlockOutputVariablesElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum BlockOutputVariablesElementTypeSerializerState<'ser> {
            Init__,
            Variable(
                IterSerializer<
                    'ser,
                    &'ser [super::BlockOutputVariablesVariableElementType],
                    super::BlockOutputVariablesVariableElementType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> BlockOutputVariablesElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        BlockOutputVariablesElementTypeSerializerState::Init__ => {
                            *self.state = BlockOutputVariablesElementTypeSerializerState::Variable(
                                IterSerializer::new(
                                    &self.value.variable[..],
                                    Some("variable"),
                                    false,
                                ),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        BlockOutputVariablesElementTypeSerializerState::Variable(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        BlockOutputVariablesElementTypeSerializerState::End__
                                }
                            }
                        }
                        BlockOutputVariablesElementTypeSerializerState::End__ => {
                            *self.state = BlockOutputVariablesElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        BlockOutputVariablesElementTypeSerializerState::Done__ => return Ok(None),
                        BlockOutputVariablesElementTypeSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for BlockOutputVariablesElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = BlockOutputVariablesElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct LeftPowerRailConnectionPointOutElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::LeftPowerRailConnectionPointOutElementType,
            pub(super) state: Box<LeftPowerRailConnectionPointOutElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum LeftPowerRailConnectionPointOutElementTypeSerializerState<'ser> {
            Init__,
            RelPosition(
                IterSerializer<'ser, Option<&'ser super::PositionType>, super::PositionType>,
            ),
            Expression(
                IterSerializer<'ser, Option<&'ser ::std::string::String>, ::std::string::String>,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> LeftPowerRailConnectionPointOutElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { LeftPowerRailConnectionPointOutElementTypeSerializerState :: Init__ => { * self . state = LeftPowerRailConnectionPointOutElementTypeSerializerState :: RelPosition (IterSerializer :: new (self . value . rel_position . as_ref () , Some ("relPosition") , false)) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } write_attrib_opt (& mut bytes , "globalId" , & self . value . global_id) ? ; write_attrib (& mut bytes , "formalParameter" , & self . value . formal_parameter) ? ; return Ok (Some (Event :: Start (bytes))) } LeftPowerRailConnectionPointOutElementTypeSerializerState :: RelPosition (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = LeftPowerRailConnectionPointOutElementTypeSerializerState :: Expression (IterSerializer :: new (self . value . expression . as_ref () , Some ("expression") , false)) , } LeftPowerRailConnectionPointOutElementTypeSerializerState :: Expression (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = LeftPowerRailConnectionPointOutElementTypeSerializerState :: AddData (IterSerializer :: new (self . value . add_data . as_ref () , Some ("addData") , false)) , } LeftPowerRailConnectionPointOutElementTypeSerializerState :: AddData (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = LeftPowerRailConnectionPointOutElementTypeSerializerState :: End__ , } LeftPowerRailConnectionPointOutElementTypeSerializerState :: End__ => { * self . state = LeftPowerRailConnectionPointOutElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } LeftPowerRailConnectionPointOutElementTypeSerializerState :: Done__ => return Ok (None) , LeftPowerRailConnectionPointOutElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for LeftPowerRailConnectionPointOutElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state =
                            LeftPowerRailConnectionPointOutElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct TransitionConditionElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::TransitionConditionElementType,
            pub(super) state: Box<TransitionConditionElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum TransitionConditionElementTypeSerializerState<'ser> {
            Init__,
            Content__(
                <super::TransitionConditionElementTypeContent as WithSerializer>::Serializer<'ser>,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> TransitionConditionElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        TransitionConditionElementTypeSerializerState::Init__ => {
                            *self.state = TransitionConditionElementTypeSerializerState::Content__(
                                WithSerializer::serializer(&self.value.content, None, false)?,
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "negated", &self.value.negated)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        TransitionConditionElementTypeSerializerState::Content__(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        TransitionConditionElementTypeSerializerState::End__
                                }
                            }
                        }
                        TransitionConditionElementTypeSerializerState::End__ => {
                            *self.state = TransitionConditionElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        TransitionConditionElementTypeSerializerState::Done__ => return Ok(None),
                        TransitionConditionElementTypeSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for TransitionConditionElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = TransitionConditionElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct TransitionConditionElementTypeContentSerializer<'ser> {
            pub(super) value: &'ser super::TransitionConditionElementTypeContent,
            pub(super) state: Box<TransitionConditionElementTypeContentSerializerState<'ser>>,
        }
        #[derive(Debug)]
        pub(super) enum TransitionConditionElementTypeContentSerializerState<'ser> {
            Init__,
            Reference(
                <super::ActionBlockActionReferenceElementType as WithSerializer>::Serializer<'ser>,
            ),
            ConnectionPointIn(<super::ConnectionPointInType as WithSerializer>::Serializer<'ser>),
            Inline(
                <super::TransitionConditionInlineElementType as WithSerializer>::Serializer<'ser>,
            ),
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> TransitionConditionElementTypeContentSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        TransitionConditionElementTypeContentSerializerState::Init__ => {
                            match self . value { super :: TransitionConditionElementTypeContent :: Reference (x) => * self . state = TransitionConditionElementTypeContentSerializerState :: Reference (WithSerializer :: serializer (x , Some ("reference") , false) ?) , super :: TransitionConditionElementTypeContent :: ConnectionPointIn (x) => * self . state = TransitionConditionElementTypeContentSerializerState :: ConnectionPointIn (WithSerializer :: serializer (x , Some ("connectionPointIn") , false) ?) , super :: TransitionConditionElementTypeContent :: Inline (x) => * self . state = TransitionConditionElementTypeContentSerializerState :: Inline (WithSerializer :: serializer (x , Some ("inline") , false) ?) , }
                        }
                        TransitionConditionElementTypeContentSerializerState::Reference(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        TransitionConditionElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        TransitionConditionElementTypeContentSerializerState::ConnectionPointIn(
                            x,
                        ) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    TransitionConditionElementTypeContentSerializerState::Done__
                            }
                        },
                        TransitionConditionElementTypeContentSerializerState::Inline(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        TransitionConditionElementTypeContentSerializerState::Done__
                                }
                            }
                        }
                        TransitionConditionElementTypeContentSerializerState::Done__ => {
                            return Ok(None)
                        }
                        TransitionConditionElementTypeContentSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for TransitionConditionElementTypeContentSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = TransitionConditionElementTypeContentSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct SelectionConvergenceConnectionPointInElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::SelectionConvergenceConnectionPointInElementType,
            pub(super) state:
                Box<SelectionConvergenceConnectionPointInElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum SelectionConvergenceConnectionPointInElementTypeSerializerState<'ser> {
            Init__,
            Content__(
                IterSerializer<
                    'ser,
                    &'ser [super::SelectionConvergenceConnectionPointInElementTypeContent],
                    super::SelectionConvergenceConnectionPointInElementTypeContent,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> SelectionConvergenceConnectionPointInElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { SelectionConvergenceConnectionPointInElementTypeSerializerState :: Init__ => { * self . state = SelectionConvergenceConnectionPointInElementTypeSerializerState :: Content__ (IterSerializer :: new (& self . value . content [..] , None , false)) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } write_attrib_opt (& mut bytes , "globalId" , & self . value . global_id) ? ; return Ok (Some (Event :: Start (bytes))) } SelectionConvergenceConnectionPointInElementTypeSerializerState :: Content__ (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SelectionConvergenceConnectionPointInElementTypeSerializerState :: End__ , } SelectionConvergenceConnectionPointInElementTypeSerializerState :: End__ => { * self . state = SelectionConvergenceConnectionPointInElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } SelectionConvergenceConnectionPointInElementTypeSerializerState :: Done__ => return Ok (None) , SelectionConvergenceConnectionPointInElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for SelectionConvergenceConnectionPointInElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state =
                            SelectionConvergenceConnectionPointInElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct SelectionConvergenceConnectionPointInElementTypeContentSerializer<'ser> {
            pub(super) value: &'ser super::SelectionConvergenceConnectionPointInElementTypeContent,
            pub(super) state:
                Box<SelectionConvergenceConnectionPointInElementTypeContentSerializerState<'ser>>,
        }
        #[derive(Debug)]
        pub(super) enum SelectionConvergenceConnectionPointInElementTypeContentSerializerState<'ser> {
            Init__,
            RelPosition(<super::PositionType as WithSerializer>::Serializer<'ser>),
            Connection(<super::ConnectionType as WithSerializer>::Serializer<'ser>),
            Expression(<::std::string::String as WithSerializer>::Serializer<'ser>),
            AddData(<super::AddDataType as WithSerializer>::Serializer<'ser>),
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> SelectionConvergenceConnectionPointInElementTypeContentSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { SelectionConvergenceConnectionPointInElementTypeContentSerializerState :: Init__ => { match self . value { super :: SelectionConvergenceConnectionPointInElementTypeContent :: RelPosition (x) => * self . state = SelectionConvergenceConnectionPointInElementTypeContentSerializerState :: RelPosition (WithSerializer :: serializer (x , Some ("relPosition") , false) ?) , super :: SelectionConvergenceConnectionPointInElementTypeContent :: Connection (x) => * self . state = SelectionConvergenceConnectionPointInElementTypeContentSerializerState :: Connection (WithSerializer :: serializer (x , Some ("connection") , false) ?) , super :: SelectionConvergenceConnectionPointInElementTypeContent :: Expression (x) => * self . state = SelectionConvergenceConnectionPointInElementTypeContentSerializerState :: Expression (WithSerializer :: serializer (x , Some ("expression") , false) ?) , super :: SelectionConvergenceConnectionPointInElementTypeContent :: AddData (x) => * self . state = SelectionConvergenceConnectionPointInElementTypeContentSerializerState :: AddData (WithSerializer :: serializer (x , Some ("addData") , false) ?) , } } SelectionConvergenceConnectionPointInElementTypeContentSerializerState :: RelPosition (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SelectionConvergenceConnectionPointInElementTypeContentSerializerState :: Done__ , } } SelectionConvergenceConnectionPointInElementTypeContentSerializerState :: Connection (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SelectionConvergenceConnectionPointInElementTypeContentSerializerState :: Done__ , } } SelectionConvergenceConnectionPointInElementTypeContentSerializerState :: Expression (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SelectionConvergenceConnectionPointInElementTypeContentSerializerState :: Done__ , } } SelectionConvergenceConnectionPointInElementTypeContentSerializerState :: AddData (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = SelectionConvergenceConnectionPointInElementTypeContentSerializerState :: Done__ , } } SelectionConvergenceConnectionPointInElementTypeContentSerializerState :: Done__ => return Ok (None) , SelectionConvergenceConnectionPointInElementTypeContentSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for SelectionConvergenceConnectionPointInElementTypeContentSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        * self . state = SelectionConvergenceConnectionPointInElementTypeContentSerializerState :: Done__ ;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct EnumValuesValueElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::EnumValuesValueElementType,
            pub(super) state: Box<EnumValuesValueElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum EnumValuesValueElementTypeSerializerState<'ser> {
            Init__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> EnumValuesValueElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        EnumValuesValueElementTypeSerializerState::Init__ => {
                            *self.state = EnumValuesValueElementTypeSerializerState::Done__;
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "name", &self.value.name)?;
                            write_attrib_opt(&mut bytes, "value", &self.value.value)?;
                            return Ok(Some(Event::Empty(bytes)));
                        }
                        EnumValuesValueElementTypeSerializerState::Done__ => return Ok(None),
                        EnumValuesValueElementTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for EnumValuesValueElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = EnumValuesValueElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectContentHeaderCoordinateInfoFbdElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectContentHeaderCoordinateInfoFbdElementType,
            pub(super) state:
                Box<ProjectContentHeaderCoordinateInfoFbdElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectContentHeaderCoordinateInfoFbdElementTypeSerializerState<'ser> {
            Init__,
            Scaling(<super::PositionType as WithSerializer>::Serializer<'ser>),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ProjectContentHeaderCoordinateInfoFbdElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { ProjectContentHeaderCoordinateInfoFbdElementTypeSerializerState :: Init__ => { * self . state = ProjectContentHeaderCoordinateInfoFbdElementTypeSerializerState :: Scaling (WithSerializer :: serializer (& self . value . scaling , Some ("scaling") , false) ?) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } return Ok (Some (Event :: Start (bytes))) } ProjectContentHeaderCoordinateInfoFbdElementTypeSerializerState :: Scaling (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectContentHeaderCoordinateInfoFbdElementTypeSerializerState :: End__ , } ProjectContentHeaderCoordinateInfoFbdElementTypeSerializerState :: End__ => { * self . state = ProjectContentHeaderCoordinateInfoFbdElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } ProjectContentHeaderCoordinateInfoFbdElementTypeSerializerState :: Done__ => return Ok (None) , ProjectContentHeaderCoordinateInfoFbdElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for ProjectContentHeaderCoordinateInfoFbdElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state =
                            ProjectContentHeaderCoordinateInfoFbdElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesDataTypesDataTypeElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectTypesDataTypesDataTypeElementType,
            pub(super) state: Box<ProjectTypesDataTypesDataTypeElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectTypesDataTypesDataTypeElementTypeSerializerState<'ser> {
            Init__,
            BaseType(<super::DataType as WithSerializer>::Serializer<'ser>),
            InitialValue(IterSerializer<'ser, Option<&'ser super::ValueType>, super::ValueType>),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ProjectTypesDataTypesDataTypeElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { ProjectTypesDataTypesDataTypeElementTypeSerializerState :: Init__ => { * self . state = ProjectTypesDataTypesDataTypeElementTypeSerializerState :: BaseType (WithSerializer :: serializer (& self . value . base_type , Some ("baseType") , false) ?) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } write_attrib (& mut bytes , "name" , & self . value . name) ? ; return Ok (Some (Event :: Start (bytes))) } ProjectTypesDataTypesDataTypeElementTypeSerializerState :: BaseType (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesDataTypesDataTypeElementTypeSerializerState :: InitialValue (IterSerializer :: new (self . value . initial_value . as_ref () , Some ("initialValue") , false)) , } ProjectTypesDataTypesDataTypeElementTypeSerializerState :: InitialValue (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesDataTypesDataTypeElementTypeSerializerState :: AddData (IterSerializer :: new (self . value . add_data . as_ref () , Some ("addData") , false)) , } ProjectTypesDataTypesDataTypeElementTypeSerializerState :: AddData (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesDataTypesDataTypeElementTypeSerializerState :: Documentation (IterSerializer :: new (self . value . documentation . as_ref () , Some ("documentation") , false)) , } ProjectTypesDataTypesDataTypeElementTypeSerializerState :: Documentation (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesDataTypesDataTypeElementTypeSerializerState :: End__ , } ProjectTypesDataTypesDataTypeElementTypeSerializerState :: End__ => { * self . state = ProjectTypesDataTypesDataTypeElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } ProjectTypesDataTypesDataTypeElementTypeSerializerState :: Done__ => return Ok (None) , ProjectTypesDataTypesDataTypeElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for ProjectTypesDataTypesDataTypeElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state =
                            ProjectTypesDataTypesDataTypeElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesPousPouElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectTypesPousPouElementType,
            pub(super) state: Box<ProjectTypesPousPouElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectTypesPousPouElementTypeSerializerState<'ser> {
            Init__,
            Interface(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ProjectTypesPousPouInterfaceElementType>,
                    super::ProjectTypesPousPouInterfaceElementType,
                >,
            ),
            Actions(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ProjectTypesPousPouActionsElementType>,
                    super::ProjectTypesPousPouActionsElementType,
                >,
            ),
            Transitions(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ProjectTypesPousPouTransitionsElementType>,
                    super::ProjectTypesPousPouTransitionsElementType,
                >,
            ),
            Body(IterSerializer<'ser, &'ser [super::BodyType], super::BodyType>),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ProjectTypesPousPouElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ProjectTypesPousPouElementTypeSerializerState::Init__ => {
                            *self.state = ProjectTypesPousPouElementTypeSerializerState::Interface(
                                IterSerializer::new(
                                    self.value.interface.as_ref(),
                                    Some("interface"),
                                    false,
                                ),
                            );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "name", &self.value.name)?;
                            write_attrib(&mut bytes, "pouType", &self.value.pou_type)?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ProjectTypesPousPouElementTypeSerializerState::Interface(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ProjectTypesPousPouElementTypeSerializerState::Actions(
                                            IterSerializer::new(
                                                self.value.actions.as_ref(),
                                                Some("actions"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        ProjectTypesPousPouElementTypeSerializerState::Actions(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ProjectTypesPousPouElementTypeSerializerState::Transitions(
                                            IterSerializer::new(
                                                self.value.transitions.as_ref(),
                                                Some("transitions"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        ProjectTypesPousPouElementTypeSerializerState::Transitions(x) => match x
                            .next()
                            .transpose()?
                        {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = ProjectTypesPousPouElementTypeSerializerState::Body(
                                    IterSerializer::new(&self.value.body[..], Some("body"), false),
                                )
                            }
                        },
                        ProjectTypesPousPouElementTypeSerializerState::Body(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ProjectTypesPousPouElementTypeSerializerState::AddData(
                                            IterSerializer::new(
                                                self.value.add_data.as_ref(),
                                                Some("addData"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        ProjectTypesPousPouElementTypeSerializerState::AddData(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ProjectTypesPousPouElementTypeSerializerState::Documentation(
                                            IterSerializer::new(
                                                self.value.documentation.as_ref(),
                                                Some("documentation"),
                                                false,
                                            ),
                                        )
                                }
                            }
                        }
                        ProjectTypesPousPouElementTypeSerializerState::Documentation(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ProjectTypesPousPouElementTypeSerializerState::End__
                                }
                            }
                        }
                        ProjectTypesPousPouElementTypeSerializerState::End__ => {
                            *self.state = ProjectTypesPousPouElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ProjectTypesPousPouElementTypeSerializerState::Done__ => return Ok(None),
                        ProjectTypesPousPouElementTypeSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for ProjectTypesPousPouElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ProjectTypesPousPouElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectInstancesConfigurationsConfigurationElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectInstancesConfigurationsConfigurationElementType,
            pub(super) state:
                Box<ProjectInstancesConfigurationsConfigurationElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectInstancesConfigurationsConfigurationElementTypeSerializerState<'ser> {
            Init__,
            Resource(
                IterSerializer<
                    'ser,
                    &'ser [super::ProjectInstancesConfigurationsConfigurationResourceElementType],
                    super::ProjectInstancesConfigurationsConfigurationResourceElementType,
                >,
            ),
            GlobalVars(IterSerializer<'ser, &'ser [super::VarListType], super::VarListType>),
            AccessVars(
                IterSerializer<
                    'ser,
                    Option<&'ser super::VarListAccessType>,
                    super::VarListAccessType,
                >,
            ),
            ConfigVars(
                IterSerializer<
                    'ser,
                    Option<&'ser super::VarListConfigType>,
                    super::VarListConfigType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ProjectInstancesConfigurationsConfigurationElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: Init__ => { * self . state = ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: Resource (IterSerializer :: new (& self . value . resource [..] , Some ("resource") , false)) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } write_attrib (& mut bytes , "name" , & self . value . name) ? ; write_attrib_opt (& mut bytes , "globalId" , & self . value . global_id) ? ; return Ok (Some (Event :: Start (bytes))) } ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: Resource (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: GlobalVars (IterSerializer :: new (& self . value . global_vars [..] , Some ("globalVars") , false)) , } ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: GlobalVars (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: AccessVars (IterSerializer :: new (self . value . access_vars . as_ref () , Some ("accessVars") , false)) , } ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: AccessVars (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: ConfigVars (IterSerializer :: new (self . value . config_vars . as_ref () , Some ("configVars") , false)) , } ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: ConfigVars (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: AddData (IterSerializer :: new (self . value . add_data . as_ref () , Some ("addData") , false)) , } ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: AddData (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: Documentation (IterSerializer :: new (self . value . documentation . as_ref () , Some ("documentation") , false)) , } ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: Documentation (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: End__ , } ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: End__ => { * self . state = ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: Done__ => return Ok (None) , ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for ProjectInstancesConfigurationsConfigurationElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        * self . state = ProjectInstancesConfigurationsConfigurationElementTypeSerializerState :: Done__ ;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ActionBlockActionReferenceElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ActionBlockActionReferenceElementType,
            pub(super) state: Box<ActionBlockActionReferenceElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ActionBlockActionReferenceElementTypeSerializerState<'ser> {
            Init__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ActionBlockActionReferenceElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ActionBlockActionReferenceElementTypeSerializerState::Init__ => {
                            *self.state =
                                ActionBlockActionReferenceElementTypeSerializerState::Done__;
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib(&mut bytes, "name", &self.value.name)?;
                            return Ok(Some(Event::Empty(bytes)));
                        }
                        ActionBlockActionReferenceElementTypeSerializerState::Done__ => {
                            return Ok(None)
                        }
                        ActionBlockActionReferenceElementTypeSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for ActionBlockActionReferenceElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ActionBlockActionReferenceElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct BlockInputVariablesVariableElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::BlockInputVariablesVariableElementType,
            pub(super) state: Box<BlockInputVariablesVariableElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum BlockInputVariablesVariableElementTypeSerializerState<'ser> {
            Init__,
            ConnectionPointIn(<super::ConnectionPointInType as WithSerializer>::Serializer<'ser>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> BlockInputVariablesVariableElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { BlockInputVariablesVariableElementTypeSerializerState :: Init__ => { * self . state = BlockInputVariablesVariableElementTypeSerializerState :: ConnectionPointIn (WithSerializer :: serializer (& self . value . connection_point_in , Some ("connectionPointIn") , false) ?) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } write_attrib (& mut bytes , "formalParameter" , & self . value . formal_parameter) ? ; write_attrib (& mut bytes , "negated" , & self . value . negated) ? ; write_attrib (& mut bytes , "edge" , & self . value . edge) ? ; write_attrib (& mut bytes , "storage" , & self . value . storage) ? ; write_attrib (& mut bytes , "hidden" , & self . value . hidden) ? ; return Ok (Some (Event :: Start (bytes))) } BlockInputVariablesVariableElementTypeSerializerState :: ConnectionPointIn (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = BlockInputVariablesVariableElementTypeSerializerState :: Documentation (IterSerializer :: new (self . value . documentation . as_ref () , Some ("documentation") , false)) , } BlockInputVariablesVariableElementTypeSerializerState :: Documentation (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = BlockInputVariablesVariableElementTypeSerializerState :: End__ , } BlockInputVariablesVariableElementTypeSerializerState :: End__ => { * self . state = BlockInputVariablesVariableElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } BlockInputVariablesVariableElementTypeSerializerState :: Done__ => return Ok (None) , BlockInputVariablesVariableElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for BlockInputVariablesVariableElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = BlockInputVariablesVariableElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct BlockInOutVariablesVariableElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::BlockInOutVariablesVariableElementType,
            pub(super) state: Box<BlockInOutVariablesVariableElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum BlockInOutVariablesVariableElementTypeSerializerState<'ser> {
            Init__,
            ConnectionPointIn(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointInType>,
                    super::ConnectionPointInType,
                >,
            ),
            ConnectionPointOut(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointOutType>,
                    super::ConnectionPointOutType,
                >,
            ),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> BlockInOutVariablesVariableElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { BlockInOutVariablesVariableElementTypeSerializerState :: Init__ => { * self . state = BlockInOutVariablesVariableElementTypeSerializerState :: ConnectionPointIn (IterSerializer :: new (self . value . connection_point_in . as_ref () , Some ("connectionPointIn") , false)) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } write_attrib (& mut bytes , "formalParameter" , & self . value . formal_parameter) ? ; write_attrib (& mut bytes , "negated" , & self . value . negated) ? ; write_attrib (& mut bytes , "edge" , & self . value . edge) ? ; write_attrib (& mut bytes , "storage" , & self . value . storage) ? ; write_attrib (& mut bytes , "hidden" , & self . value . hidden) ? ; return Ok (Some (Event :: Start (bytes))) } BlockInOutVariablesVariableElementTypeSerializerState :: ConnectionPointIn (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = BlockInOutVariablesVariableElementTypeSerializerState :: ConnectionPointOut (IterSerializer :: new (self . value . connection_point_out . as_ref () , Some ("connectionPointOut") , false)) , } BlockInOutVariablesVariableElementTypeSerializerState :: ConnectionPointOut (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = BlockInOutVariablesVariableElementTypeSerializerState :: Documentation (IterSerializer :: new (self . value . documentation . as_ref () , Some ("documentation") , false)) , } BlockInOutVariablesVariableElementTypeSerializerState :: Documentation (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = BlockInOutVariablesVariableElementTypeSerializerState :: End__ , } BlockInOutVariablesVariableElementTypeSerializerState :: End__ => { * self . state = BlockInOutVariablesVariableElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } BlockInOutVariablesVariableElementTypeSerializerState :: Done__ => return Ok (None) , BlockInOutVariablesVariableElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for BlockInOutVariablesVariableElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = BlockInOutVariablesVariableElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct BlockOutputVariablesVariableElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::BlockOutputVariablesVariableElementType,
            pub(super) state: Box<BlockOutputVariablesVariableElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum BlockOutputVariablesVariableElementTypeSerializerState<'ser> {
            Init__,
            ConnectionPointOut(
                IterSerializer<
                    'ser,
                    Option<&'ser super::ConnectionPointOutType>,
                    super::ConnectionPointOutType,
                >,
            ),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> BlockOutputVariablesVariableElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { BlockOutputVariablesVariableElementTypeSerializerState :: Init__ => { * self . state = BlockOutputVariablesVariableElementTypeSerializerState :: ConnectionPointOut (IterSerializer :: new (self . value . connection_point_out . as_ref () , Some ("connectionPointOut") , false)) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } write_attrib (& mut bytes , "formalParameter" , & self . value . formal_parameter) ? ; write_attrib (& mut bytes , "negated" , & self . value . negated) ? ; write_attrib (& mut bytes , "edge" , & self . value . edge) ? ; write_attrib (& mut bytes , "storage" , & self . value . storage) ? ; write_attrib (& mut bytes , "hidden" , & self . value . hidden) ? ; return Ok (Some (Event :: Start (bytes))) } BlockOutputVariablesVariableElementTypeSerializerState :: ConnectionPointOut (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = BlockOutputVariablesVariableElementTypeSerializerState :: Documentation (IterSerializer :: new (self . value . documentation . as_ref () , Some ("documentation") , false)) , } BlockOutputVariablesVariableElementTypeSerializerState :: Documentation (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = BlockOutputVariablesVariableElementTypeSerializerState :: End__ , } BlockOutputVariablesVariableElementTypeSerializerState :: End__ => { * self . state = BlockOutputVariablesVariableElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } BlockOutputVariablesVariableElementTypeSerializerState :: Done__ => return Ok (None) , BlockOutputVariablesVariableElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for BlockOutputVariablesVariableElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state =
                            BlockOutputVariablesVariableElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct TransitionConditionInlineElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::TransitionConditionInlineElementType,
            pub(super) state: Box<TransitionConditionInlineElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum TransitionConditionInlineElementTypeSerializerState<'ser> {
            Init__,
            Content__(
                IterSerializer<
                    'ser,
                    &'ser [super::TransitionConditionInlineElementTypeContent],
                    super::TransitionConditionInlineElementTypeContent,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> TransitionConditionInlineElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        TransitionConditionInlineElementTypeSerializerState::Init__ => {
                            *self.state =
                                TransitionConditionInlineElementTypeSerializerState::Content__(
                                    IterSerializer::new(&self.value.content[..], None, false),
                                );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            write_attrib_opt(
                                &mut bytes,
                                "WorksheetName",
                                &self.value.worksheet_name,
                            )?;
                            write_attrib_opt(&mut bytes, "globalId", &self.value.global_id)?;
                            write_attrib(&mut bytes, "name", &self.value.name)?;
                            return Ok(Some(Event::Start(bytes)));
                        }
                        TransitionConditionInlineElementTypeSerializerState::Content__(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        TransitionConditionInlineElementTypeSerializerState::End__
                                }
                            }
                        }
                        TransitionConditionInlineElementTypeSerializerState::End__ => {
                            *self.state =
                                TransitionConditionInlineElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        TransitionConditionInlineElementTypeSerializerState::Done__ => {
                            return Ok(None)
                        }
                        TransitionConditionInlineElementTypeSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for TransitionConditionInlineElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = TransitionConditionInlineElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct TransitionConditionInlineElementTypeContentSerializer<'ser> {
            pub(super) value: &'ser super::TransitionConditionInlineElementTypeContent,
            pub(super) state: Box<TransitionConditionInlineElementTypeContentSerializerState<'ser>>,
        }
        #[derive(Debug)]
        pub(super) enum TransitionConditionInlineElementTypeContentSerializerState<'ser> {
            Init__,
            Il(<super::FormattedTextType as WithSerializer>::Serializer<'ser>),
            St(<super::FormattedTextType as WithSerializer>::Serializer<'ser>),
            Fbd(<super::BodyFbdElementType as WithSerializer>::Serializer<'ser>),
            Ld(<super::BodyLdElementType as WithSerializer>::Serializer<'ser>),
            Sfc(<super::BodySfcElementType as WithSerializer>::Serializer<'ser>),
            AddData(<super::AddDataType as WithSerializer>::Serializer<'ser>),
            Documentation(<super::FormattedTextType as WithSerializer>::Serializer<'ser>),
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> TransitionConditionInlineElementTypeContentSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { TransitionConditionInlineElementTypeContentSerializerState :: Init__ => { match self . value { super :: TransitionConditionInlineElementTypeContent :: Il (x) => * self . state = TransitionConditionInlineElementTypeContentSerializerState :: Il (WithSerializer :: serializer (x , Some ("IL") , false) ?) , super :: TransitionConditionInlineElementTypeContent :: St (x) => * self . state = TransitionConditionInlineElementTypeContentSerializerState :: St (WithSerializer :: serializer (x , Some ("ST") , false) ?) , super :: TransitionConditionInlineElementTypeContent :: Fbd (x) => * self . state = TransitionConditionInlineElementTypeContentSerializerState :: Fbd (WithSerializer :: serializer (x , Some ("FBD") , false) ?) , super :: TransitionConditionInlineElementTypeContent :: Ld (x) => * self . state = TransitionConditionInlineElementTypeContentSerializerState :: Ld (WithSerializer :: serializer (x , Some ("LD") , false) ?) , super :: TransitionConditionInlineElementTypeContent :: Sfc (x) => * self . state = TransitionConditionInlineElementTypeContentSerializerState :: Sfc (WithSerializer :: serializer (x , Some ("SFC") , false) ?) , super :: TransitionConditionInlineElementTypeContent :: AddData (x) => * self . state = TransitionConditionInlineElementTypeContentSerializerState :: AddData (WithSerializer :: serializer (x , Some ("addData") , false) ?) , super :: TransitionConditionInlineElementTypeContent :: Documentation (x) => * self . state = TransitionConditionInlineElementTypeContentSerializerState :: Documentation (WithSerializer :: serializer (x , Some ("documentation") , false) ?) , } } TransitionConditionInlineElementTypeContentSerializerState :: Il (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TransitionConditionInlineElementTypeContentSerializerState :: Done__ , } } TransitionConditionInlineElementTypeContentSerializerState :: St (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TransitionConditionInlineElementTypeContentSerializerState :: Done__ , } } TransitionConditionInlineElementTypeContentSerializerState :: Fbd (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TransitionConditionInlineElementTypeContentSerializerState :: Done__ , } } TransitionConditionInlineElementTypeContentSerializerState :: Ld (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TransitionConditionInlineElementTypeContentSerializerState :: Done__ , } } TransitionConditionInlineElementTypeContentSerializerState :: Sfc (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TransitionConditionInlineElementTypeContentSerializerState :: Done__ , } } TransitionConditionInlineElementTypeContentSerializerState :: AddData (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TransitionConditionInlineElementTypeContentSerializerState :: Done__ , } } TransitionConditionInlineElementTypeContentSerializerState :: Documentation (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TransitionConditionInlineElementTypeContentSerializerState :: Done__ , } } TransitionConditionInlineElementTypeContentSerializerState :: Done__ => return Ok (None) , TransitionConditionInlineElementTypeContentSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for TransitionConditionInlineElementTypeContentSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state =
                            TransitionConditionInlineElementTypeContentSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesPousPouInterfaceElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectTypesPousPouInterfaceElementType,
            pub(super) state: Box<ProjectTypesPousPouInterfaceElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectTypesPousPouInterfaceElementTypeSerializerState<'ser> {
            Init__,
            Content__(
                IterSerializer<
                    'ser,
                    &'ser [super::ProjectTypesPousPouInterfaceElementTypeContent],
                    super::ProjectTypesPousPouInterfaceElementTypeContent,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ProjectTypesPousPouInterfaceElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ProjectTypesPousPouInterfaceElementTypeSerializerState::Init__ => {
                            *self.state =
                                ProjectTypesPousPouInterfaceElementTypeSerializerState::Content__(
                                    IterSerializer::new(&self.value.content[..], None, false),
                                );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ProjectTypesPousPouInterfaceElementTypeSerializerState::Content__(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state =
                                    ProjectTypesPousPouInterfaceElementTypeSerializerState::End__,
                            }
                        }
                        ProjectTypesPousPouInterfaceElementTypeSerializerState::End__ => {
                            *self.state =
                                ProjectTypesPousPouInterfaceElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ProjectTypesPousPouInterfaceElementTypeSerializerState::Done__ => {
                            return Ok(None)
                        }
                        ProjectTypesPousPouInterfaceElementTypeSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for ProjectTypesPousPouInterfaceElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state =
                            ProjectTypesPousPouInterfaceElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesPousPouInterfaceElementTypeContentSerializer<'ser> {
            pub(super) value: &'ser super::ProjectTypesPousPouInterfaceElementTypeContent,
            pub(super) state:
                Box<ProjectTypesPousPouInterfaceElementTypeContentSerializerState<'ser>>,
        }
        #[derive(Debug)]
        pub(super) enum ProjectTypesPousPouInterfaceElementTypeContentSerializerState<'ser> {
            Init__ , ReturnType (< super :: DataType as WithSerializer > :: Serializer < 'ser >) , LocalVars (< super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithSerializer > :: Serializer < 'ser >) , TempVars (< super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithSerializer > :: Serializer < 'ser >) , InputVars (< super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithSerializer > :: Serializer < 'ser >) , OutputVars (< super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithSerializer > :: Serializer < 'ser >) , InOutVars (< super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithSerializer > :: Serializer < 'ser >) , ExternalVars (< super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithSerializer > :: Serializer < 'ser >) , GlobalVars (< super :: ProjectTypesPousPouInterfaceExternalVarsElementType as WithSerializer > :: Serializer < 'ser >) , AccessVars (< super :: VarListType as WithSerializer > :: Serializer < 'ser >) , AddData (< super :: AddDataType as WithSerializer > :: Serializer < 'ser >) , Documentation (< super :: FormattedTextType as WithSerializer > :: Serializer < 'ser >) , Done__ , Phantom__ (& 'ser ()) , }
        impl<'ser> ProjectTypesPousPouInterfaceElementTypeContentSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: Init__ => { match self . value { super :: ProjectTypesPousPouInterfaceElementTypeContent :: ReturnType (x) => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: ReturnType (WithSerializer :: serializer (x , Some ("returnType") , false) ?) , super :: ProjectTypesPousPouInterfaceElementTypeContent :: LocalVars (x) => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: LocalVars (WithSerializer :: serializer (x , Some ("localVars") , false) ?) , super :: ProjectTypesPousPouInterfaceElementTypeContent :: TempVars (x) => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: TempVars (WithSerializer :: serializer (x , Some ("tempVars") , false) ?) , super :: ProjectTypesPousPouInterfaceElementTypeContent :: InputVars (x) => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: InputVars (WithSerializer :: serializer (x , Some ("inputVars") , false) ?) , super :: ProjectTypesPousPouInterfaceElementTypeContent :: OutputVars (x) => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: OutputVars (WithSerializer :: serializer (x , Some ("outputVars") , false) ?) , super :: ProjectTypesPousPouInterfaceElementTypeContent :: InOutVars (x) => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: InOutVars (WithSerializer :: serializer (x , Some ("inOutVars") , false) ?) , super :: ProjectTypesPousPouInterfaceElementTypeContent :: ExternalVars (x) => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: ExternalVars (WithSerializer :: serializer (x , Some ("externalVars") , false) ?) , super :: ProjectTypesPousPouInterfaceElementTypeContent :: GlobalVars (x) => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: GlobalVars (WithSerializer :: serializer (x , Some ("globalVars") , false) ?) , super :: ProjectTypesPousPouInterfaceElementTypeContent :: AccessVars (x) => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: AccessVars (WithSerializer :: serializer (x , Some ("accessVars") , false) ?) , super :: ProjectTypesPousPouInterfaceElementTypeContent :: AddData (x) => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: AddData (WithSerializer :: serializer (x , Some ("addData") , false) ?) , super :: ProjectTypesPousPouInterfaceElementTypeContent :: Documentation (x) => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: Documentation (WithSerializer :: serializer (x , Some ("documentation") , false) ?) , } } ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: ReturnType (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: Done__ , } } ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: LocalVars (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: Done__ , } } ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: TempVars (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: Done__ , } } ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: InputVars (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: Done__ , } } ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: OutputVars (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: Done__ , } } ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: InOutVars (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: Done__ , } } ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: ExternalVars (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: Done__ , } } ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: GlobalVars (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: Done__ , } } ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: AccessVars (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: Done__ , } } ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: AddData (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: Done__ , } } ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: Documentation (x) => { match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: Done__ , } } ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: Done__ => return Ok (None) , ProjectTypesPousPouInterfaceElementTypeContentSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for ProjectTypesPousPouInterfaceElementTypeContentSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state =
                            ProjectTypesPousPouInterfaceElementTypeContentSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesPousPouActionsElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectTypesPousPouActionsElementType,
            pub(super) state: Box<ProjectTypesPousPouActionsElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectTypesPousPouActionsElementTypeSerializerState<'ser> {
            Init__,
            Action(
                IterSerializer<
                    'ser,
                    &'ser [super::ProjectTypesPousPouActionsActionElementType],
                    super::ProjectTypesPousPouActionsActionElementType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ProjectTypesPousPouActionsElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ProjectTypesPousPouActionsElementTypeSerializerState::Init__ => {
                            *self.state =
                                ProjectTypesPousPouActionsElementTypeSerializerState::Action(
                                    IterSerializer::new(
                                        &self.value.action[..],
                                        Some("action"),
                                        false,
                                    ),
                                );
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ProjectTypesPousPouActionsElementTypeSerializerState::Action(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => {
                                    *self.state =
                                        ProjectTypesPousPouActionsElementTypeSerializerState::End__
                                }
                            }
                        }
                        ProjectTypesPousPouActionsElementTypeSerializerState::End__ => {
                            *self.state =
                                ProjectTypesPousPouActionsElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ProjectTypesPousPouActionsElementTypeSerializerState::Done__ => {
                            return Ok(None)
                        }
                        ProjectTypesPousPouActionsElementTypeSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for ProjectTypesPousPouActionsElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = ProjectTypesPousPouActionsElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesPousPouTransitionsElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectTypesPousPouTransitionsElementType,
            pub(super) state: Box<ProjectTypesPousPouTransitionsElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectTypesPousPouTransitionsElementTypeSerializerState<'ser> {
            Init__,
            Transition(
                IterSerializer<
                    'ser,
                    &'ser [super::ProjectTypesPousPouActionsActionElementType],
                    super::ProjectTypesPousPouActionsActionElementType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ProjectTypesPousPouTransitionsElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        ProjectTypesPousPouTransitionsElementTypeSerializerState::Init__ => {
                            * self . state = ProjectTypesPousPouTransitionsElementTypeSerializerState :: Transition (IterSerializer :: new (& self . value . transition [..] , Some ("transition") , false)) ;
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            return Ok(Some(Event::Start(bytes)));
                        }
                        ProjectTypesPousPouTransitionsElementTypeSerializerState::Transition(x) => {
                            match x.next().transpose()? {
                                Some(event) => return Ok(Some(event)),
                                None => *self.state =
                                    ProjectTypesPousPouTransitionsElementTypeSerializerState::End__,
                            }
                        }
                        ProjectTypesPousPouTransitionsElementTypeSerializerState::End__ => {
                            *self.state =
                                ProjectTypesPousPouTransitionsElementTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        ProjectTypesPousPouTransitionsElementTypeSerializerState::Done__ => {
                            return Ok(None)
                        }
                        ProjectTypesPousPouTransitionsElementTypeSerializerState::Phantom__(_) => {
                            unreachable!()
                        }
                    }
                }
            }
        }
        impl<'ser> Iterator for ProjectTypesPousPouTransitionsElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state =
                            ProjectTypesPousPouTransitionsElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializer<'ser> {
            pub(super) value:
                &'ser super::ProjectInstancesConfigurationsConfigurationResourceElementType,
            pub(super) state: Box<
                ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState<'ser>,
            >,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState<
            'ser,
        > {
            Init__ , Task (IterSerializer < 'ser , & 'ser [super :: ProjectInstancesConfigurationsConfigurationResourceTaskElementType] , super :: ProjectInstancesConfigurationsConfigurationResourceTaskElementType >) , GlobalVars (IterSerializer < 'ser , & 'ser [super :: VarListType] , super :: VarListType >) , PouInstance (IterSerializer < 'ser , & 'ser [super :: PouInstanceType] , super :: PouInstanceType >) , AddData (IterSerializer < 'ser , Option < & 'ser super :: AddDataType > , super :: AddDataType >) , Documentation (IterSerializer < 'ser , Option < & 'ser super :: FormattedTextType > , super :: FormattedTextType >) , End__ , Done__ , Phantom__ (& 'ser ()) , }
        impl<'ser> ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: Init__ => { * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: Task (IterSerializer :: new (& self . value . task [..] , Some ("task") , false)) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } write_attrib (& mut bytes , "name" , & self . value . name) ? ; write_attrib_opt (& mut bytes , "globalId" , & self . value . global_id) ? ; return Ok (Some (Event :: Start (bytes))) } ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: Task (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: GlobalVars (IterSerializer :: new (& self . value . global_vars [..] , Some ("globalVars") , false)) , } ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: GlobalVars (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: PouInstance (IterSerializer :: new (& self . value . pou_instance [..] , Some ("pouInstance") , false)) , } ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: PouInstance (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: AddData (IterSerializer :: new (self . value . add_data . as_ref () , Some ("addData") , false)) , } ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: AddData (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: Documentation (IterSerializer :: new (self . value . documentation . as_ref () , Some ("documentation") , false)) , } ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: Documentation (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: End__ , } ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: End__ => { * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: Done__ => return Ok (None) , ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator
            for ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializer<'ser>
        {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        * self . state = ProjectInstancesConfigurationsConfigurationResourceElementTypeSerializerState :: Done__ ;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectTypesPousPouInterfaceExternalVarsElementType,
            pub(super) state:
                Box<ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializerState<'ser> {
            Init__,
            Variable(
                IterSerializer<
                    'ser,
                    &'ser [super::VarListPlainVariableElementType],
                    super::VarListPlainVariableElementType,
                >,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializerState :: Init__ => { * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializerState :: Variable (IterSerializer :: new (& self . value . variable [..] , Some ("variable") , false)) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } write_attrib_opt (& mut bytes , "name" , & self . value . name) ? ; write_attrib (& mut bytes , "constant" , & self . value . constant) ? ; write_attrib (& mut bytes , "retain" , & self . value . retain) ? ; write_attrib (& mut bytes , "nonretain" , & self . value . nonretain) ? ; write_attrib (& mut bytes , "persistent" , & self . value . persistent) ? ; write_attrib (& mut bytes , "nonpersistent" , & self . value . nonpersistent) ? ; return Ok (Some (Event :: Start (bytes))) } ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializerState :: Variable (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializerState :: AddData (IterSerializer :: new (self . value . add_data . as_ref () , Some ("addData") , false)) , } ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializerState :: AddData (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializerState :: Documentation (IterSerializer :: new (self . value . documentation . as_ref () , Some ("documentation") , false)) , } ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializerState :: Documentation (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializerState :: End__ , } ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializerState :: End__ => { * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializerState :: Done__ => return Ok (None) , ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        * self . state = ProjectTypesPousPouInterfaceExternalVarsElementTypeSerializerState :: Done__ ;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectTypesPousPouActionsActionElementTypeSerializer<'ser> {
            pub(super) value: &'ser super::ProjectTypesPousPouActionsActionElementType,
            pub(super) state: Box<ProjectTypesPousPouActionsActionElementTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectTypesPousPouActionsActionElementTypeSerializerState<'ser> {
            Init__,
            Body(<super::BodyType as WithSerializer>::Serializer<'ser>),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ProjectTypesPousPouActionsActionElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { ProjectTypesPousPouActionsActionElementTypeSerializerState :: Init__ => { * self . state = ProjectTypesPousPouActionsActionElementTypeSerializerState :: Body (WithSerializer :: serializer (& self . value . body , Some ("body") , false) ?) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } write_attrib (& mut bytes , "name" , & self . value . name) ? ; write_attrib_opt (& mut bytes , "globalId" , & self . value . global_id) ? ; return Ok (Some (Event :: Start (bytes))) } ProjectTypesPousPouActionsActionElementTypeSerializerState :: Body (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesPousPouActionsActionElementTypeSerializerState :: AddData (IterSerializer :: new (self . value . add_data . as_ref () , Some ("addData") , false)) , } ProjectTypesPousPouActionsActionElementTypeSerializerState :: AddData (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesPousPouActionsActionElementTypeSerializerState :: Documentation (IterSerializer :: new (self . value . documentation . as_ref () , Some ("documentation") , false)) , } ProjectTypesPousPouActionsActionElementTypeSerializerState :: Documentation (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectTypesPousPouActionsActionElementTypeSerializerState :: End__ , } ProjectTypesPousPouActionsActionElementTypeSerializerState :: End__ => { * self . state = ProjectTypesPousPouActionsActionElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } ProjectTypesPousPouActionsActionElementTypeSerializerState :: Done__ => return Ok (None) , ProjectTypesPousPouActionsActionElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator for ProjectTypesPousPouActionsActionElementTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state =
                            ProjectTypesPousPouActionsActionElementTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
        #[derive(Debug)]
        pub struct ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializer<
            'ser,
        > {
            pub(super) value:
                &'ser super::ProjectInstancesConfigurationsConfigurationResourceTaskElementType,
            pub(super) state: Box<
                ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializerState<
                    'ser,
                >,
            >,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializerState<
            'ser,
        > {
            Init__,
            PouInstance(
                IterSerializer<'ser, &'ser [super::PouInstanceType], super::PouInstanceType>,
            ),
            AddData(IterSerializer<'ser, Option<&'ser super::AddDataType>, super::AddDataType>),
            Documentation(
                IterSerializer<
                    'ser,
                    Option<&'ser super::FormattedTextType>,
                    super::FormattedTextType,
                >,
            ),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match & mut * self . state { ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializerState :: Init__ => { * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializerState :: PouInstance (IterSerializer :: new (& self . value . pou_instance [..] , Some ("pouInstance") , false)) ; let mut bytes = BytesStart :: new (self . name) ; if self . is_root { bytes . push_attribute ((& b"xmlns" [..] , & super :: super :: NS_PPX [..])) ; } write_attrib (& mut bytes , "name" , & self . value . name) ? ; write_attrib_opt (& mut bytes , "single" , & self . value . single) ? ; write_attrib_opt (& mut bytes , "interval" , & self . value . interval) ? ; write_attrib (& mut bytes , "priority" , & self . value . priority) ? ; write_attrib_opt (& mut bytes , "globalId" , & self . value . global_id) ? ; return Ok (Some (Event :: Start (bytes))) } ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializerState :: PouInstance (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializerState :: AddData (IterSerializer :: new (self . value . add_data . as_ref () , Some ("addData") , false)) , } ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializerState :: AddData (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializerState :: Documentation (IterSerializer :: new (self . value . documentation . as_ref () , Some ("documentation") , false)) , } ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializerState :: Documentation (x) => match x . next () . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializerState :: End__ , } ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializerState :: End__ => { * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializerState :: Done__ ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializerState :: Done__ => return Ok (None) , ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
                }
            }
        }
        impl<'ser> Iterator
            for ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializer<'ser>
        {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        * self . state = ProjectInstancesConfigurationsConfigurationResourceTaskElementTypeSerializerState :: Done__ ;
                        Some(Err(error))
                    }
                }
            }
        }
    }
}
pub mod xs {
    use num::{BigInt, BigUint};
    use std::borrow::Cow;
    use xsd_parser::{
        quick_xml::{
            DeserializeBytes, DeserializeReader, Error, SerializeBytes, WithDeserializer,
            WithSerializer,
        },
        xml::{AnyAttributes, AnyElement},
    };
    #[derive(Debug, Default)]
    pub struct EntitiesType(pub Vec<::std::string::String>);
    impl DeserializeBytes for EntitiesType {
        fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, Error>
        where
            R: DeserializeReader,
        {
            Ok(Self(
                bytes
                    .split(|b| *b == b' ' || *b == b'|' || *b == b',' || *b == b';')
                    .map(|bytes| ::std::string::String::deserialize_bytes(reader, bytes))
                    .collect::<Result<Vec<_>, _>>()?,
            ))
        }
    }
    impl SerializeBytes for EntitiesType {
        fn serialize_bytes(&self) -> Result<Option<Cow<'_, str>>, Error> {
            if self.0.is_empty() {
                return Ok(None);
            }
            let mut data = String::new();
            for item in &self.0 {
                if let Some(bytes) = item.serialize_bytes()? {
                    if !data.is_empty() {
                        data.push(' ');
                    }
                    data.push_str(&bytes);
                }
            }
            Ok(Some(Cow::Owned(data)))
        }
    }
    pub type EntityType = EntitiesType;
    pub type IdType = ::std::string::String;
    pub type IdrefType = ::std::string::String;
    pub type IdrefsType = EntitiesType;
    pub type NcNameType = ::std::string::String;
    pub type NmtokenType = ::std::string::String;
    pub type NmtokensType = EntitiesType;
    pub type NotationType = ::std::string::String;
    pub type NameType = ::std::string::String;
    pub type QNameType = ::std::string::String;
    pub type AnySimpleType = ::std::string::String;
    #[derive(Debug)]
    pub struct AnyType {
        pub any_attribute: AnyAttributes,
        pub any: Vec<AnyElement>,
    }
    impl WithDeserializer for AnyType {
        type Deserializer = Box<quick_xml_deserialize::AnyTypeDeserializer>;
    }
    impl WithSerializer for AnyType {
        type Serializer<'x> = quick_xml_serialize::AnyTypeSerializer<'x>;
        fn serializer<'ser>(
            &'ser self,
            name: Option<&'ser str>,
            is_root: bool,
        ) -> Result<Self::Serializer<'ser>, Error> {
            Ok(quick_xml_serialize::AnyTypeSerializer {
                value: self,
                state: Box::new(quick_xml_serialize::AnyTypeSerializerState::Init__),
                name: name.unwrap_or("anyType"),
                is_root,
            })
        }
    }
    pub type AnyUriType = ::std::string::String;
    pub type Base64BinaryType = ::std::string::String;
    pub type BooleanType = ::core::primitive::bool;
    pub type ByteType = ::core::primitive::i8;
    pub type DateType = ::std::string::String;
    pub type DateTimeType = ::std::string::String;
    pub type DecimalType = ::core::primitive::f64;
    pub type DoubleType = ::core::primitive::f64;
    pub type DurationType = ::std::string::String;
    pub type FloatType = ::core::primitive::f32;
    pub type GDayType = ::std::string::String;
    pub type GMonthType = ::std::string::String;
    pub type GMonthDayType = ::std::string::String;
    pub type GYearType = ::std::string::String;
    pub type GYearMonthType = ::std::string::String;
    pub type HexBinaryType = ::std::string::String;
    pub type IntType = ::core::primitive::i32;
    pub type IntegerType = BigInt;
    pub type LanguageType = ::std::string::String;
    pub type LongType = ::core::primitive::i64;
    pub type NegativeIntegerType = BigInt;
    pub type NonNegativeIntegerType = BigUint;
    pub type NonPositiveIntegerType = BigInt;
    pub type NormalizedStringType = ::std::string::String;
    pub type PositiveIntegerType = BigUint;
    pub type ShortType = ::core::primitive::i16;
    pub type StringType = ::std::string::String;
    pub type TimeType = ::std::string::String;
    pub type TokenType = ::std::string::String;
    pub type UnsignedByteType = ::core::primitive::u8;
    pub type UnsignedIntType = ::core::primitive::u32;
    pub type UnsignedLongType = ::core::primitive::u64;
    pub type UnsignedShortType = ::core::primitive::u16;
    pub mod quick_xml_deserialize {
        use core::mem::replace;
        use xsd_parser::{
            quick_xml::{
                filter_xmlns_attributes, BytesStart, DeserializeReader, Deserializer,
                DeserializerArtifact, DeserializerEvent, DeserializerOutput, DeserializerResult,
                ElementHandlerOutput, Error, Event, WithDeserializer,
            },
            xml::{AnyAttributes, AnyElement},
        };
        #[derive(Debug)]
        pub struct AnyTypeDeserializer {
            any_attribute: AnyAttributes,
            any: Vec<AnyElement>,
            state: Box<AnyTypeDeserializerState>,
        }
        #[derive(Debug)]
        enum AnyTypeDeserializerState {
            Init__,
            Any(Option<<AnyElement as WithDeserializer>::Deserializer>),
            Done__,
            Unknown__,
        }
        impl AnyTypeDeserializer {
            fn from_bytes_start<R>(
                reader: &R,
                bytes_start: &BytesStart<'_>,
            ) -> Result<Box<Self>, Error>
            where
                R: DeserializeReader,
            {
                let mut any_attribute = AnyAttributes::default();
                for attrib in filter_xmlns_attributes(bytes_start) {
                    let attrib = attrib?;
                    any_attribute.push(attrib)?;
                }
                Ok(Box::new(Self {
                    any_attribute: any_attribute,
                    any: Vec::new(),
                    state: Box::new(AnyTypeDeserializerState::Init__),
                }))
            }
            fn finish_state<R>(
                &mut self,
                reader: &R,
                state: AnyTypeDeserializerState,
            ) -> Result<(), Error>
            where
                R: DeserializeReader,
            {
                use AnyTypeDeserializerState as S;
                match state {
                    S::Any(Some(deserializer)) => self.store_any(deserializer.finish(reader)?)?,
                    _ => (),
                }
                Ok(())
            }
            fn store_any(&mut self, value: AnyElement) -> Result<(), Error> {
                self.any.push(value);
                Ok(())
            }
            fn handle_any<'de, R>(
                &mut self,
                reader: &R,
                output: DeserializerOutput<'de, AnyElement>,
                fallback: &mut Option<AnyTypeDeserializerState>,
            ) -> Result<ElementHandlerOutput<'de>, Error>
            where
                R: DeserializeReader,
            {
                let DeserializerOutput {
                    artifact,
                    event,
                    allow_any,
                } = output;
                if artifact.is_none() {
                    fallback.get_or_insert(AnyTypeDeserializerState::Any(None));
                    *self.state = AnyTypeDeserializerState::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(reader, fallback)?;
                }
                Ok(match artifact {
                    DeserializerArtifact::None => unreachable!(),
                    DeserializerArtifact::Data(data) => {
                        self.store_any(data)?;
                        *self.state = AnyTypeDeserializerState::Any(None);
                        ElementHandlerOutput::from_event(event, allow_any)
                    }
                    DeserializerArtifact::Deserializer(deserializer) => {
                        let ret = ElementHandlerOutput::from_event(event, allow_any);
                        match &ret {
                            ElementHandlerOutput::Continue { .. } => {
                                fallback.get_or_insert(AnyTypeDeserializerState::Any(Some(
                                    deserializer,
                                )));
                                *self.state = AnyTypeDeserializerState::Any(None);
                            }
                            ElementHandlerOutput::Break { .. } => {
                                *self.state = AnyTypeDeserializerState::Any(Some(deserializer));
                            }
                        }
                        ret
                    }
                })
            }
        }
        impl<'de> Deserializer<'de, super::AnyType> for Box<AnyTypeDeserializer> {
            fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, super::AnyType>
            where
                R: DeserializeReader,
            {
                reader.init_deserializer_from_start_event(
                    event,
                    AnyTypeDeserializer::from_bytes_start,
                )
            }
            fn next<R>(
                mut self,
                reader: &R,
                event: Event<'de>,
            ) -> DeserializerResult<'de, super::AnyType>
            where
                R: DeserializeReader,
            {
                use AnyTypeDeserializerState as S;
                let mut event = event;
                let mut fallback = None;
                let mut allow_any_element = false;
                let mut is_any_retry = false;
                let mut any_fallback = None;
                let (event, allow_any) = loop {
                    let state = replace(&mut *self.state, S::Unknown__);
                    event = match (state, event) {
                        (S::Any(Some(deserializer)), event) => {
                            let output = deserializer.next(reader, event)?;
                            match self.handle_any(reader, output, &mut fallback)? {
                                ElementHandlerOutput::Continue { event, allow_any } => {
                                    allow_any_element = allow_any_element || allow_any;
                                    event
                                }
                                ElementHandlerOutput::Break { event, allow_any } => {
                                    break (event, allow_any)
                                }
                            }
                        }
                        (_, Event::End(_)) => {
                            if let Some(fallback) = fallback.take() {
                                self.finish_state(reader, fallback)?;
                            }
                            return Ok(DeserializerOutput {
                                artifact: DeserializerArtifact::Data(self.finish(reader)?),
                                event: DeserializerEvent::None,
                                allow_any: false,
                            });
                        }
                        (S::Init__, event) => {
                            fallback.get_or_insert(S::Init__);
                            *self.state = AnyTypeDeserializerState::Any(None);
                            event
                        }
                        (S::Any(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                            if is_any_retry {
                                let output = <AnyElement as WithDeserializer>::Deserializer::init(
                                    reader, event,
                                )?;
                                match self.handle_any(reader, output, &mut fallback)? {
                                    ElementHandlerOutput::Continue { event, allow_any } => {
                                        allow_any_element = allow_any_element || allow_any;
                                        event
                                    }
                                    ElementHandlerOutput::Break { event, allow_any } => {
                                        break (event, allow_any)
                                    }
                                }
                            } else {
                                any_fallback.get_or_insert(S::Any(None));
                                *self.state = S::Done__;
                                event
                            }
                        }
                        (S::Done__, event) => {
                            if let Some(state) = any_fallback.take() {
                                is_any_retry = true;
                                *self.state = state;
                                event
                            } else {
                                fallback.get_or_insert(S::Done__);
                                break (DeserializerEvent::Continue(event), allow_any_element);
                            }
                        }
                        (S::Unknown__, _) => unreachable!(),
                        (state, event) => {
                            *self.state = state;
                            break (DeserializerEvent::Break(event), false);
                        }
                    }
                };
                if let Some(fallback) = fallback {
                    *self.state = fallback;
                }
                Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::Deserializer(self),
                    event,
                    allow_any,
                })
            }
            fn finish<R>(mut self, reader: &R) -> Result<super::AnyType, Error>
            where
                R: DeserializeReader,
            {
                let state = replace(&mut *self.state, AnyTypeDeserializerState::Unknown__);
                self.finish_state(reader, state)?;
                Ok(super::AnyType {
                    any_attribute: self.any_attribute,
                    any: self.any,
                })
            }
        }
    }
    pub mod quick_xml_serialize {
        use core::iter::Iterator;
        use xsd_parser::{
            quick_xml::{BytesEnd, BytesStart, Error, Event, IterSerializer},
            xml::AnyElement,
        };
        #[derive(Debug)]
        pub struct AnyTypeSerializer<'ser> {
            pub(super) value: &'ser super::AnyType,
            pub(super) state: Box<AnyTypeSerializerState<'ser>>,
            pub(super) name: &'ser str,
            pub(super) is_root: bool,
        }
        #[derive(Debug)]
        pub(super) enum AnyTypeSerializerState<'ser> {
            Init__,
            Any(IterSerializer<'ser, &'ser [AnyElement], AnyElement>),
            End__,
            Done__,
            Phantom__(&'ser ()),
        }
        impl<'ser> AnyTypeSerializer<'ser> {
            fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
                loop {
                    match &mut *self.state {
                        AnyTypeSerializerState::Init__ => {
                            *self.state = AnyTypeSerializerState::Any(IterSerializer::new(
                                &self.value.any[..],
                                Some("any"),
                                false,
                            ));
                            let mut bytes = BytesStart::new(self.name);
                            if self.is_root {
                                bytes.push_attribute((&b"xmlns"[..], &super::super::NS_PPX[..]));
                            }
                            bytes.extend_attributes(self.value.any_attribute.attributes());
                            return Ok(Some(Event::Start(bytes)));
                        }
                        AnyTypeSerializerState::Any(x) => match x.next().transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = AnyTypeSerializerState::End__,
                        },
                        AnyTypeSerializerState::End__ => {
                            *self.state = AnyTypeSerializerState::Done__;
                            return Ok(Some(Event::End(BytesEnd::new(self.name))));
                        }
                        AnyTypeSerializerState::Done__ => return Ok(None),
                        AnyTypeSerializerState::Phantom__(_) => unreachable!(),
                    }
                }
            }
        }
        impl<'ser> Iterator for AnyTypeSerializer<'ser> {
            type Item = Result<Event<'ser>, Error>;
            fn next(&mut self) -> Option<Self::Item> {
                match self.next_event() {
                    Ok(Some(event)) => Some(Ok(event)),
                    Ok(None) => None,
                    Err(error) => {
                        *self.state = AnyTypeSerializerState::Done__;
                        Some(Err(error))
                    }
                }
            }
        }
    }
}