xsd-parser 1.5.2

use std::borrow::Cow;
use xsd_parser_types::{
    misc::{Namespace, NamespacePrefix},
    quick_xml::{
        DeserializeBytes, DeserializeHelper, Error, ErrorKind, RawByteStr, SerializeBytes,
        SerializeHelper, WithDeserializer, WithDeserializerFromBytes, WithSerializeToBytes,
        WithSerializer,
    },
};
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_XSI: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema-instance");
pub const NS_UNNAMED_5: Namespace =
    Namespace::new_const(b"http://www.etim-international.com/bmecat/31");
pub const PREFIX_XS: NamespacePrefix = NamespacePrefix::new_const(b"xs");
pub const PREFIX_XML: NamespacePrefix = NamespacePrefix::new_const(b"xml");
pub const PREFIX_XSI: NamespacePrefix = NamespacePrefix::new_const(b"xsi");
pub type BmecatElement = BmecatElementType;
#[derive(Debug)]
pub struct BmecatElementType {
    pub version: TypeBmEcatVersion,
    pub content: Vec<BmecatElementTypeContent>,
}
#[derive(Debug)]
pub enum BmecatElementTypeContent {
    Header(HeaderElementType),
    TNewCatalog(TNewCatalogElementType),
    TUpdateProducts(TUpdateProductsElementType),
    TUpdatePrices(TUpdatePricesElementType),
}
impl WithSerializer for BmecatElementType {
    type Serializer<'x> = quick_xml_serialize::BmecatElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::BmecatElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::BmecatElementTypeSerializerState::Init__),
            name: name.unwrap_or("BMECAT"),
            is_root,
        })
    }
}
impl WithSerializer for BmecatElementTypeContent {
    type Serializer<'x> = quick_xml_serialize::BmecatElementTypeContentSerializer<'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::BmecatElementTypeContentSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::BmecatElementTypeContentSerializerState::Init__),
        })
    }
}
impl WithDeserializer for BmecatElementType {
    type Deserializer = quick_xml_deserialize::BmecatElementTypeDeserializer;
}
impl WithDeserializer for BmecatElementTypeContent {
    type Deserializer = quick_xml_deserialize::BmecatElementTypeContentDeserializer;
}
#[derive(Debug)]
pub enum TypeBmEcatVersion {
    _12,
    _2005,
}
impl SerializeBytes for TypeBmEcatVersion {
    fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
        match self {
            Self::_12 => Ok(Some(Cow::Borrowed("1.2"))),
            Self::_2005 => Ok(Some(Cow::Borrowed("2005"))),
        }
    }
}
impl WithSerializeToBytes for TypeBmEcatVersion {}
impl DeserializeBytes for TypeBmEcatVersion {
    fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
        match bytes {
            b"1.2" => Ok(Self::_12),
            b"2005" => Ok(Self::_2005),
            x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
                RawByteStr::from_slice(x),
            ))),
        }
    }
}
impl WithDeserializerFromBytes for TypeBmEcatVersion {}
#[derive(Debug)]
pub struct HeaderElementType {
    pub generator_info: Option<String>,
    pub catalog: CatalogElementType,
    pub buyer: BuyerElementType,
    pub supplier: SupplierElementType,
    pub user_defined_extensions: UdxHeader,
}
impl WithSerializer for HeaderElementType {
    type Serializer<'x> = quick_xml_serialize::HeaderElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::HeaderElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::HeaderElementTypeSerializerState::Init__),
            name: name.unwrap_or("HEADER"),
            is_root,
        })
    }
}
impl WithDeserializer for HeaderElementType {
    type Deserializer = quick_xml_deserialize::HeaderElementTypeDeserializer;
}
#[derive(Debug)]
pub struct TNewCatalogElementType {
    pub product: Vec<TNewCatalogProductElementType>,
}
impl WithSerializer for TNewCatalogElementType {
    type Serializer<'x> = quick_xml_serialize::TNewCatalogElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::TNewCatalogElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::TNewCatalogElementTypeSerializerState::Init__),
            name: name.unwrap_or("T_NEW_CATALOG"),
            is_root,
        })
    }
}
impl WithDeserializer for TNewCatalogElementType {
    type Deserializer = quick_xml_deserialize::TNewCatalogElementTypeDeserializer;
}
#[derive(Debug)]
pub struct TUpdateProductsElementType {
    pub prev_version: i32,
    pub product: Vec<TUpdateProductsProductElementType>,
}
impl WithSerializer for TUpdateProductsElementType {
    type Serializer<'x> = quick_xml_serialize::TUpdateProductsElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::TUpdateProductsElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::TUpdateProductsElementTypeSerializerState::Init__),
            name: name.unwrap_or("T_UPDATE_PRODUCTS"),
            is_root,
        })
    }
}
impl WithDeserializer for TUpdateProductsElementType {
    type Deserializer = quick_xml_deserialize::TUpdateProductsElementTypeDeserializer;
}
#[derive(Debug)]
pub struct TUpdatePricesElementType {
    pub prev_version: i32,
    pub product: Vec<TUpdatePricesProductElementType>,
}
impl WithSerializer for TUpdatePricesElementType {
    type Serializer<'x> = quick_xml_serialize::TUpdatePricesElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::TUpdatePricesElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::TUpdatePricesElementTypeSerializerState::Init__),
            name: name.unwrap_or("T_UPDATE_PRICES"),
            is_root,
        })
    }
}
impl WithDeserializer for TUpdatePricesElementType {
    type Deserializer = quick_xml_deserialize::TUpdatePricesElementTypeDeserializer;
}
#[derive(Debug)]
pub struct CatalogElementType {
    pub language: Vec<LanguageElementType>,
    pub catalog_id: String,
    pub catalog_version: String,
    pub catalog_name: Vec<DtMlstring>,
    pub datetime: CatalogDatetimeElementType,
    pub territory: Vec<String>,
    pub currency: Option<DtCurrencies>,
    pub mime_root: Vec<DtMlstring>,
}
impl WithSerializer for CatalogElementType {
    type Serializer<'x> = quick_xml_serialize::CatalogElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::CatalogElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::CatalogElementTypeSerializerState::Init__),
            name: name.unwrap_or("CATALOG"),
            is_root,
        })
    }
}
impl WithDeserializer for CatalogElementType {
    type Deserializer = quick_xml_deserialize::CatalogElementTypeDeserializer;
}
#[derive(Debug)]
pub struct BuyerElementType {
    pub buyer_id: Option<TypePartyId>,
    pub buyer_name: String,
}
impl WithSerializer for BuyerElementType {
    type Serializer<'x> = quick_xml_serialize::BuyerElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::BuyerElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::BuyerElementTypeSerializerState::Init__),
            name: name.unwrap_or("BUYER"),
            is_root,
        })
    }
}
impl WithDeserializer for BuyerElementType {
    type Deserializer = quick_xml_deserialize::BuyerElementTypeDeserializer;
}
#[derive(Debug)]
pub struct SupplierElementType {
    pub supplier_id: Vec<TypePartyId>,
    pub supplier_name: String,
    pub address: Option<SupplierAddressElementType>,
    pub mime_info: Option<MimeInfoElementType>,
}
impl WithSerializer for SupplierElementType {
    type Serializer<'x> = quick_xml_serialize::SupplierElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::SupplierElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::SupplierElementTypeSerializerState::Init__),
            name: name.unwrap_or("SUPPLIER"),
            is_root,
        })
    }
}
impl WithDeserializer for SupplierElementType {
    type Deserializer = quick_xml_deserialize::SupplierElementTypeDeserializer;
}
#[derive(Debug)]
pub struct UdxHeader {
    pub udx_edxf_version: String,
}
impl WithSerializer for UdxHeader {
    type Serializer<'x> = quick_xml_serialize::UdxHeaderSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::UdxHeaderSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::UdxHeaderSerializerState::Init__),
            name: name.unwrap_or("udxHEADER"),
            is_root,
        })
    }
}
impl WithDeserializer for UdxHeader {
    type Deserializer = quick_xml_deserialize::UdxHeaderDeserializer;
}
#[derive(Debug)]
pub struct TNewCatalogProductElementType {
    pub mode: TNewCatalogProductMode,
    pub supplier_pid: SupplierPidElementType,
    pub product_details: ProductDetailsElementType,
    pub product_features: Vec<ProductFeaturesElementType>,
    pub product_order_details: ProductOrderDetailsElementType,
    pub product_price_details: Vec<ProductPriceDetailsElementType>,
    pub mime_info: Option<MimeInfoElementType>,
    pub user_defined_extensions: UdxProduct,
    pub product_reference: Vec<ProductReferenceElementType>,
    pub product_logistic_details: Option<ProductLogisticDetailsElementType>,
}
impl TNewCatalogProductElementType {
    #[must_use]
    pub fn default_mode() -> TNewCatalogProductMode {
        TNewCatalogProductMode::New
    }
}
impl WithSerializer for TNewCatalogProductElementType {
    type Serializer<'x> = quick_xml_serialize::TNewCatalogProductElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(
            quick_xml_serialize::TNewCatalogProductElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::TNewCatalogProductElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("TNewCatalogProduct"),
                is_root,
            },
        )
    }
}
impl WithDeserializer for TNewCatalogProductElementType {
    type Deserializer = quick_xml_deserialize::TNewCatalogProductElementTypeDeserializer;
}
#[derive(Debug)]
pub struct TUpdateProductsProductElementType {
    pub mode: TUpdateProductsProductMode,
    pub supplier_pid: SupplierPidElementType,
    pub product_details: ProductDetailsElementType,
    pub product_features: Vec<ProductFeaturesElementType>,
    pub product_order_details: ProductOrderDetailsElementType,
    pub product_price_details: Vec<ProductPriceDetailsElementType>,
    pub mime_info: Option<MimeInfoElementType>,
    pub user_defined_extensions: Option<UdxProduct>,
    pub product_reference: Vec<ProductReferenceElementType>,
    pub product_logistic_details: Option<ProductLogisticDetailsElementType>,
}
impl WithSerializer for TUpdateProductsProductElementType {
    type Serializer<'x> = quick_xml_serialize::TUpdateProductsProductElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(
            quick_xml_serialize::TUpdateProductsProductElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::TUpdateProductsProductElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("TUpdateProductsProduct"),
                is_root,
            },
        )
    }
}
impl WithDeserializer for TUpdateProductsProductElementType {
    type Deserializer = quick_xml_deserialize::TUpdateProductsProductElementTypeDeserializer;
}
#[derive(Debug)]
pub struct TUpdatePricesProductElementType {
    pub mode: TUpdatePricesProductMode,
    pub supplier_pid: SupplierPidElementType,
    pub product_price_details: Vec<ProductPriceDetailsElementType>,
    pub user_defined_extensions: Option<UdxProduct>,
}
impl TUpdatePricesProductElementType {
    #[must_use]
    pub fn default_mode() -> TUpdatePricesProductMode {
        TUpdatePricesProductMode::Update
    }
}
impl WithSerializer for TUpdatePricesProductElementType {
    type Serializer<'x> = quick_xml_serialize::TUpdatePricesProductElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(
            quick_xml_serialize::TUpdatePricesProductElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::TUpdatePricesProductElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("TUpdatePricesProduct"),
                is_root,
            },
        )
    }
}
impl WithDeserializer for TUpdatePricesProductElementType {
    type Deserializer = quick_xml_deserialize::TUpdatePricesProductElementTypeDeserializer;
}
#[derive(Debug)]
pub struct LanguageElementType {
    pub default: Option<String>,
    pub content: DtLang,
}
impl WithSerializer for LanguageElementType {
    type Serializer<'x> = quick_xml_serialize::LanguageElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::LanguageElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::LanguageElementTypeSerializerState::Init__),
            name: name.unwrap_or("LANGUAGE"),
            is_root,
        })
    }
}
impl WithDeserializer for LanguageElementType {
    type Deserializer = quick_xml_deserialize::LanguageElementTypeDeserializer;
}
#[derive(Debug)]
pub struct DtMlstring {
    pub lang: Option<DtLang>,
    pub content: String,
}
impl WithSerializer for DtMlstring {
    type Serializer<'x> = quick_xml_serialize::DtMlstringSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::DtMlstringSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::DtMlstringSerializerState::Init__),
            name: name.unwrap_or("dtMLSTRING"),
            is_root,
        })
    }
}
impl WithDeserializer for DtMlstring {
    type Deserializer = quick_xml_deserialize::DtMlstringDeserializer;
}
#[derive(Debug)]
pub struct CatalogDatetimeElementType {
    pub type_: CatalogDatetimeType,
    pub date: String,
    pub time: Option<String>,
    pub timezone: Option<String>,
}
impl WithSerializer for CatalogDatetimeElementType {
    type Serializer<'x> = quick_xml_serialize::CatalogDatetimeElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::CatalogDatetimeElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::CatalogDatetimeElementTypeSerializerState::Init__),
            name: name.unwrap_or("CatalogDatetime"),
            is_root,
        })
    }
}
impl WithDeserializer for CatalogDatetimeElementType {
    type Deserializer = quick_xml_deserialize::CatalogDatetimeElementTypeDeserializer;
}
#[derive(Debug)]
pub enum DtCurrencies {
    Adp,
    Aed,
    Afa,
    All,
    Ang,
    Aok,
    Ara,
    Ats,
    Aud,
    Awg,
    Bbd,
    Bdt,
    Bef,
    Bgl,
    Bhd,
    Bif,
    Bmd,
    Bnd,
    Bob,
    Brc,
    Bsd,
    Btn,
    Buk,
    Bwp,
    Bzd,
    Cad,
    Chf,
    Clf,
    Clp,
    Cny,
    Cop,
    Crc,
    Csk,
    Cup,
    Cve,
    Cyp,
    Ddm,
    Dem,
    Djf,
    Dkk,
    Dop,
    Dzd,
    Ecs,
    Egp,
    Esp,
    Etb,
    Eur,
    Fim,
    Fjd,
    Fkp,
    Frf,
    Gbp,
    Ghc,
    Gip,
    Gmd,
    Gnf,
    Grd,
    Gtq,
    Gwp,
    Gyd,
    Hkd,
    Hnl,
    Htg,
    Huf,
    Idr,
    Iep,
    Ils,
    Inr,
    Iqd,
    Irr,
    Isk,
    Itl,
    Jmd,
    Jod,
    Jpy,
    Kes,
    Khr,
    Kmf,
    Kpw,
    Krw,
    Kwd,
    Kyd,
    Lak,
    Lbp,
    Lkr,
    Lrd,
    Lsl,
    Luf,
    Lyd,
    Mad,
    Mgf,
    Mnt,
    Mop,
    Mro,
    Mtl,
    Mur,
    Mvr,
    Mwk,
    Mxp,
    Myr,
    Mzm,
    Ngn,
    Nic,
    Nlg,
    Nok,
    Npr,
    Nzd,
    Omr,
    Pab,
    Pei,
    Pgk,
    Php,
    Pkr,
    Plz,
    Pln,
    Pte,
    Pyg,
    Qar,
    Rol,
    Rwf,
    Sar,
    Sbd,
    Scr,
    Sdp,
    Sek,
    Sgd,
    Shp,
    Sll,
    Skk,
    Sos,
    Srg,
    Std,
    Sur,
    Svc,
    Syp,
    Szl,
    Thb,
    Tnd,
    Top,
    Tpe,
    Trl,
    Ttd,
    Twd,
    Tzs,
    Ugs,
    Usd,
    Uyp,
    Veb,
    Vnd,
    Vuv,
    Wst,
    Ydd,
    Yer,
    Yud,
    Zar,
    Zmk,
    Zrz,
    Zwd,
}
impl SerializeBytes for DtCurrencies {
    fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
        match self {
            Self::Adp => Ok(Some(Cow::Borrowed("ADP"))),
            Self::Aed => Ok(Some(Cow::Borrowed("AED"))),
            Self::Afa => Ok(Some(Cow::Borrowed("AFA"))),
            Self::All => Ok(Some(Cow::Borrowed("ALL"))),
            Self::Ang => Ok(Some(Cow::Borrowed("ANG"))),
            Self::Aok => Ok(Some(Cow::Borrowed("AOK"))),
            Self::Ara => Ok(Some(Cow::Borrowed("ARA"))),
            Self::Ats => Ok(Some(Cow::Borrowed("ATS"))),
            Self::Aud => Ok(Some(Cow::Borrowed("AUD"))),
            Self::Awg => Ok(Some(Cow::Borrowed("AWG"))),
            Self::Bbd => Ok(Some(Cow::Borrowed("BBD"))),
            Self::Bdt => Ok(Some(Cow::Borrowed("BDT"))),
            Self::Bef => Ok(Some(Cow::Borrowed("BEF"))),
            Self::Bgl => Ok(Some(Cow::Borrowed("BGL"))),
            Self::Bhd => Ok(Some(Cow::Borrowed("BHD"))),
            Self::Bif => Ok(Some(Cow::Borrowed("BIF"))),
            Self::Bmd => Ok(Some(Cow::Borrowed("BMD"))),
            Self::Bnd => Ok(Some(Cow::Borrowed("BND"))),
            Self::Bob => Ok(Some(Cow::Borrowed("BOB"))),
            Self::Brc => Ok(Some(Cow::Borrowed("BRC"))),
            Self::Bsd => Ok(Some(Cow::Borrowed("BSD"))),
            Self::Btn => Ok(Some(Cow::Borrowed("BTN"))),
            Self::Buk => Ok(Some(Cow::Borrowed("BUK"))),
            Self::Bwp => Ok(Some(Cow::Borrowed("BWP"))),
            Self::Bzd => Ok(Some(Cow::Borrowed("BZD"))),
            Self::Cad => Ok(Some(Cow::Borrowed("CAD"))),
            Self::Chf => Ok(Some(Cow::Borrowed("CHF"))),
            Self::Clf => Ok(Some(Cow::Borrowed("CLF"))),
            Self::Clp => Ok(Some(Cow::Borrowed("CLP"))),
            Self::Cny => Ok(Some(Cow::Borrowed("CNY"))),
            Self::Cop => Ok(Some(Cow::Borrowed("COP"))),
            Self::Crc => Ok(Some(Cow::Borrowed("CRC"))),
            Self::Csk => Ok(Some(Cow::Borrowed("CSK"))),
            Self::Cup => Ok(Some(Cow::Borrowed("CUP"))),
            Self::Cve => Ok(Some(Cow::Borrowed("CVE"))),
            Self::Cyp => Ok(Some(Cow::Borrowed("CYP"))),
            Self::Ddm => Ok(Some(Cow::Borrowed("DDM"))),
            Self::Dem => Ok(Some(Cow::Borrowed("DEM"))),
            Self::Djf => Ok(Some(Cow::Borrowed("DJF"))),
            Self::Dkk => Ok(Some(Cow::Borrowed("DKK"))),
            Self::Dop => Ok(Some(Cow::Borrowed("DOP"))),
            Self::Dzd => Ok(Some(Cow::Borrowed("DZD"))),
            Self::Ecs => Ok(Some(Cow::Borrowed("ECS"))),
            Self::Egp => Ok(Some(Cow::Borrowed("EGP"))),
            Self::Esp => Ok(Some(Cow::Borrowed("ESP"))),
            Self::Etb => Ok(Some(Cow::Borrowed("ETB"))),
            Self::Eur => Ok(Some(Cow::Borrowed("EUR"))),
            Self::Fim => Ok(Some(Cow::Borrowed("FIM"))),
            Self::Fjd => Ok(Some(Cow::Borrowed("FJD"))),
            Self::Fkp => Ok(Some(Cow::Borrowed("FKP"))),
            Self::Frf => Ok(Some(Cow::Borrowed("FRF"))),
            Self::Gbp => Ok(Some(Cow::Borrowed("GBP"))),
            Self::Ghc => Ok(Some(Cow::Borrowed("GHC"))),
            Self::Gip => Ok(Some(Cow::Borrowed("GIP"))),
            Self::Gmd => Ok(Some(Cow::Borrowed("GMD"))),
            Self::Gnf => Ok(Some(Cow::Borrowed("GNF"))),
            Self::Grd => Ok(Some(Cow::Borrowed("GRD"))),
            Self::Gtq => Ok(Some(Cow::Borrowed("GTQ"))),
            Self::Gwp => Ok(Some(Cow::Borrowed("GWP"))),
            Self::Gyd => Ok(Some(Cow::Borrowed("GYD"))),
            Self::Hkd => Ok(Some(Cow::Borrowed("HKD"))),
            Self::Hnl => Ok(Some(Cow::Borrowed("HNL"))),
            Self::Htg => Ok(Some(Cow::Borrowed("HTG"))),
            Self::Huf => Ok(Some(Cow::Borrowed("HUF"))),
            Self::Idr => Ok(Some(Cow::Borrowed("IDR"))),
            Self::Iep => Ok(Some(Cow::Borrowed("IEP"))),
            Self::Ils => Ok(Some(Cow::Borrowed("ILS"))),
            Self::Inr => Ok(Some(Cow::Borrowed("INR"))),
            Self::Iqd => Ok(Some(Cow::Borrowed("IQD"))),
            Self::Irr => Ok(Some(Cow::Borrowed("IRR"))),
            Self::Isk => Ok(Some(Cow::Borrowed("ISK"))),
            Self::Itl => Ok(Some(Cow::Borrowed("ITL"))),
            Self::Jmd => Ok(Some(Cow::Borrowed("JMD"))),
            Self::Jod => Ok(Some(Cow::Borrowed("JOD"))),
            Self::Jpy => Ok(Some(Cow::Borrowed("JPY"))),
            Self::Kes => Ok(Some(Cow::Borrowed("KES"))),
            Self::Khr => Ok(Some(Cow::Borrowed("KHR"))),
            Self::Kmf => Ok(Some(Cow::Borrowed("KMF"))),
            Self::Kpw => Ok(Some(Cow::Borrowed("KPW"))),
            Self::Krw => Ok(Some(Cow::Borrowed("KRW"))),
            Self::Kwd => Ok(Some(Cow::Borrowed("KWD"))),
            Self::Kyd => Ok(Some(Cow::Borrowed("KYD"))),
            Self::Lak => Ok(Some(Cow::Borrowed("LAK"))),
            Self::Lbp => Ok(Some(Cow::Borrowed("LBP"))),
            Self::Lkr => Ok(Some(Cow::Borrowed("LKR"))),
            Self::Lrd => Ok(Some(Cow::Borrowed("LRD"))),
            Self::Lsl => Ok(Some(Cow::Borrowed("LSL"))),
            Self::Luf => Ok(Some(Cow::Borrowed("LUF"))),
            Self::Lyd => Ok(Some(Cow::Borrowed("LYD"))),
            Self::Mad => Ok(Some(Cow::Borrowed("MAD"))),
            Self::Mgf => Ok(Some(Cow::Borrowed("MGF"))),
            Self::Mnt => Ok(Some(Cow::Borrowed("MNT"))),
            Self::Mop => Ok(Some(Cow::Borrowed("MOP"))),
            Self::Mro => Ok(Some(Cow::Borrowed("MRO"))),
            Self::Mtl => Ok(Some(Cow::Borrowed("MTL"))),
            Self::Mur => Ok(Some(Cow::Borrowed("MUR"))),
            Self::Mvr => Ok(Some(Cow::Borrowed("MVR"))),
            Self::Mwk => Ok(Some(Cow::Borrowed("MWK"))),
            Self::Mxp => Ok(Some(Cow::Borrowed("MXP"))),
            Self::Myr => Ok(Some(Cow::Borrowed("MYR"))),
            Self::Mzm => Ok(Some(Cow::Borrowed("MZM"))),
            Self::Ngn => Ok(Some(Cow::Borrowed("NGN"))),
            Self::Nic => Ok(Some(Cow::Borrowed("NIC"))),
            Self::Nlg => Ok(Some(Cow::Borrowed("NLG"))),
            Self::Nok => Ok(Some(Cow::Borrowed("NOK"))),
            Self::Npr => Ok(Some(Cow::Borrowed("NPR"))),
            Self::Nzd => Ok(Some(Cow::Borrowed("NZD"))),
            Self::Omr => Ok(Some(Cow::Borrowed("OMR"))),
            Self::Pab => Ok(Some(Cow::Borrowed("PAB"))),
            Self::Pei => Ok(Some(Cow::Borrowed("PEI"))),
            Self::Pgk => Ok(Some(Cow::Borrowed("PGK"))),
            Self::Php => Ok(Some(Cow::Borrowed("PHP"))),
            Self::Pkr => Ok(Some(Cow::Borrowed("PKR"))),
            Self::Plz => Ok(Some(Cow::Borrowed("PLZ"))),
            Self::Pln => Ok(Some(Cow::Borrowed("PLN"))),
            Self::Pte => Ok(Some(Cow::Borrowed("PTE"))),
            Self::Pyg => Ok(Some(Cow::Borrowed("PYG"))),
            Self::Qar => Ok(Some(Cow::Borrowed("QAR"))),
            Self::Rol => Ok(Some(Cow::Borrowed("ROL"))),
            Self::Rwf => Ok(Some(Cow::Borrowed("RWF"))),
            Self::Sar => Ok(Some(Cow::Borrowed("SAR"))),
            Self::Sbd => Ok(Some(Cow::Borrowed("SBD"))),
            Self::Scr => Ok(Some(Cow::Borrowed("SCR"))),
            Self::Sdp => Ok(Some(Cow::Borrowed("SDP"))),
            Self::Sek => Ok(Some(Cow::Borrowed("SEK"))),
            Self::Sgd => Ok(Some(Cow::Borrowed("SGD"))),
            Self::Shp => Ok(Some(Cow::Borrowed("SHP"))),
            Self::Sll => Ok(Some(Cow::Borrowed("SLL"))),
            Self::Skk => Ok(Some(Cow::Borrowed("SKK"))),
            Self::Sos => Ok(Some(Cow::Borrowed("SOS"))),
            Self::Srg => Ok(Some(Cow::Borrowed("SRG"))),
            Self::Std => Ok(Some(Cow::Borrowed("STD"))),
            Self::Sur => Ok(Some(Cow::Borrowed("SUR"))),
            Self::Svc => Ok(Some(Cow::Borrowed("SVC"))),
            Self::Syp => Ok(Some(Cow::Borrowed("SYP"))),
            Self::Szl => Ok(Some(Cow::Borrowed("SZL"))),
            Self::Thb => Ok(Some(Cow::Borrowed("THB"))),
            Self::Tnd => Ok(Some(Cow::Borrowed("TND"))),
            Self::Top => Ok(Some(Cow::Borrowed("TOP"))),
            Self::Tpe => Ok(Some(Cow::Borrowed("TPE"))),
            Self::Trl => Ok(Some(Cow::Borrowed("TRL"))),
            Self::Ttd => Ok(Some(Cow::Borrowed("TTD"))),
            Self::Twd => Ok(Some(Cow::Borrowed("TWD"))),
            Self::Tzs => Ok(Some(Cow::Borrowed("TZS"))),
            Self::Ugs => Ok(Some(Cow::Borrowed("UGS"))),
            Self::Usd => Ok(Some(Cow::Borrowed("USD"))),
            Self::Uyp => Ok(Some(Cow::Borrowed("UYP"))),
            Self::Veb => Ok(Some(Cow::Borrowed("VEB"))),
            Self::Vnd => Ok(Some(Cow::Borrowed("VND"))),
            Self::Vuv => Ok(Some(Cow::Borrowed("VUV"))),
            Self::Wst => Ok(Some(Cow::Borrowed("WST"))),
            Self::Ydd => Ok(Some(Cow::Borrowed("YDD"))),
            Self::Yer => Ok(Some(Cow::Borrowed("YER"))),
            Self::Yud => Ok(Some(Cow::Borrowed("YUD"))),
            Self::Zar => Ok(Some(Cow::Borrowed("ZAR"))),
            Self::Zmk => Ok(Some(Cow::Borrowed("ZMK"))),
            Self::Zrz => Ok(Some(Cow::Borrowed("ZRZ"))),
            Self::Zwd => Ok(Some(Cow::Borrowed("ZWD"))),
        }
    }
}
impl WithSerializeToBytes for DtCurrencies {}
impl DeserializeBytes for DtCurrencies {
    fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
        match bytes {
            b"ADP" => Ok(Self::Adp),
            b"AED" => Ok(Self::Aed),
            b"AFA" => Ok(Self::Afa),
            b"ALL" => Ok(Self::All),
            b"ANG" => Ok(Self::Ang),
            b"AOK" => Ok(Self::Aok),
            b"ARA" => Ok(Self::Ara),
            b"ATS" => Ok(Self::Ats),
            b"AUD" => Ok(Self::Aud),
            b"AWG" => Ok(Self::Awg),
            b"BBD" => Ok(Self::Bbd),
            b"BDT" => Ok(Self::Bdt),
            b"BEF" => Ok(Self::Bef),
            b"BGL" => Ok(Self::Bgl),
            b"BHD" => Ok(Self::Bhd),
            b"BIF" => Ok(Self::Bif),
            b"BMD" => Ok(Self::Bmd),
            b"BND" => Ok(Self::Bnd),
            b"BOB" => Ok(Self::Bob),
            b"BRC" => Ok(Self::Brc),
            b"BSD" => Ok(Self::Bsd),
            b"BTN" => Ok(Self::Btn),
            b"BUK" => Ok(Self::Buk),
            b"BWP" => Ok(Self::Bwp),
            b"BZD" => Ok(Self::Bzd),
            b"CAD" => Ok(Self::Cad),
            b"CHF" => Ok(Self::Chf),
            b"CLF" => Ok(Self::Clf),
            b"CLP" => Ok(Self::Clp),
            b"CNY" => Ok(Self::Cny),
            b"COP" => Ok(Self::Cop),
            b"CRC" => Ok(Self::Crc),
            b"CSK" => Ok(Self::Csk),
            b"CUP" => Ok(Self::Cup),
            b"CVE" => Ok(Self::Cve),
            b"CYP" => Ok(Self::Cyp),
            b"DDM" => Ok(Self::Ddm),
            b"DEM" => Ok(Self::Dem),
            b"DJF" => Ok(Self::Djf),
            b"DKK" => Ok(Self::Dkk),
            b"DOP" => Ok(Self::Dop),
            b"DZD" => Ok(Self::Dzd),
            b"ECS" => Ok(Self::Ecs),
            b"EGP" => Ok(Self::Egp),
            b"ESP" => Ok(Self::Esp),
            b"ETB" => Ok(Self::Etb),
            b"EUR" => Ok(Self::Eur),
            b"FIM" => Ok(Self::Fim),
            b"FJD" => Ok(Self::Fjd),
            b"FKP" => Ok(Self::Fkp),
            b"FRF" => Ok(Self::Frf),
            b"GBP" => Ok(Self::Gbp),
            b"GHC" => Ok(Self::Ghc),
            b"GIP" => Ok(Self::Gip),
            b"GMD" => Ok(Self::Gmd),
            b"GNF" => Ok(Self::Gnf),
            b"GRD" => Ok(Self::Grd),
            b"GTQ" => Ok(Self::Gtq),
            b"GWP" => Ok(Self::Gwp),
            b"GYD" => Ok(Self::Gyd),
            b"HKD" => Ok(Self::Hkd),
            b"HNL" => Ok(Self::Hnl),
            b"HTG" => Ok(Self::Htg),
            b"HUF" => Ok(Self::Huf),
            b"IDR" => Ok(Self::Idr),
            b"IEP" => Ok(Self::Iep),
            b"ILS" => Ok(Self::Ils),
            b"INR" => Ok(Self::Inr),
            b"IQD" => Ok(Self::Iqd),
            b"IRR" => Ok(Self::Irr),
            b"ISK" => Ok(Self::Isk),
            b"ITL" => Ok(Self::Itl),
            b"JMD" => Ok(Self::Jmd),
            b"JOD" => Ok(Self::Jod),
            b"JPY" => Ok(Self::Jpy),
            b"KES" => Ok(Self::Kes),
            b"KHR" => Ok(Self::Khr),
            b"KMF" => Ok(Self::Kmf),
            b"KPW" => Ok(Self::Kpw),
            b"KRW" => Ok(Self::Krw),
            b"KWD" => Ok(Self::Kwd),
            b"KYD" => Ok(Self::Kyd),
            b"LAK" => Ok(Self::Lak),
            b"LBP" => Ok(Self::Lbp),
            b"LKR" => Ok(Self::Lkr),
            b"LRD" => Ok(Self::Lrd),
            b"LSL" => Ok(Self::Lsl),
            b"LUF" => Ok(Self::Luf),
            b"LYD" => Ok(Self::Lyd),
            b"MAD" => Ok(Self::Mad),
            b"MGF" => Ok(Self::Mgf),
            b"MNT" => Ok(Self::Mnt),
            b"MOP" => Ok(Self::Mop),
            b"MRO" => Ok(Self::Mro),
            b"MTL" => Ok(Self::Mtl),
            b"MUR" => Ok(Self::Mur),
            b"MVR" => Ok(Self::Mvr),
            b"MWK" => Ok(Self::Mwk),
            b"MXP" => Ok(Self::Mxp),
            b"MYR" => Ok(Self::Myr),
            b"MZM" => Ok(Self::Mzm),
            b"NGN" => Ok(Self::Ngn),
            b"NIC" => Ok(Self::Nic),
            b"NLG" => Ok(Self::Nlg),
            b"NOK" => Ok(Self::Nok),
            b"NPR" => Ok(Self::Npr),
            b"NZD" => Ok(Self::Nzd),
            b"OMR" => Ok(Self::Omr),
            b"PAB" => Ok(Self::Pab),
            b"PEI" => Ok(Self::Pei),
            b"PGK" => Ok(Self::Pgk),
            b"PHP" => Ok(Self::Php),
            b"PKR" => Ok(Self::Pkr),
            b"PLZ" => Ok(Self::Plz),
            b"PLN" => Ok(Self::Pln),
            b"PTE" => Ok(Self::Pte),
            b"PYG" => Ok(Self::Pyg),
            b"QAR" => Ok(Self::Qar),
            b"ROL" => Ok(Self::Rol),
            b"RWF" => Ok(Self::Rwf),
            b"SAR" => Ok(Self::Sar),
            b"SBD" => Ok(Self::Sbd),
            b"SCR" => Ok(Self::Scr),
            b"SDP" => Ok(Self::Sdp),
            b"SEK" => Ok(Self::Sek),
            b"SGD" => Ok(Self::Sgd),
            b"SHP" => Ok(Self::Shp),
            b"SLL" => Ok(Self::Sll),
            b"SKK" => Ok(Self::Skk),
            b"SOS" => Ok(Self::Sos),
            b"SRG" => Ok(Self::Srg),
            b"STD" => Ok(Self::Std),
            b"SUR" => Ok(Self::Sur),
            b"SVC" => Ok(Self::Svc),
            b"SYP" => Ok(Self::Syp),
            b"SZL" => Ok(Self::Szl),
            b"THB" => Ok(Self::Thb),
            b"TND" => Ok(Self::Tnd),
            b"TOP" => Ok(Self::Top),
            b"TPE" => Ok(Self::Tpe),
            b"TRL" => Ok(Self::Trl),
            b"TTD" => Ok(Self::Ttd),
            b"TWD" => Ok(Self::Twd),
            b"TZS" => Ok(Self::Tzs),
            b"UGS" => Ok(Self::Ugs),
            b"USD" => Ok(Self::Usd),
            b"UYP" => Ok(Self::Uyp),
            b"VEB" => Ok(Self::Veb),
            b"VND" => Ok(Self::Vnd),
            b"VUV" => Ok(Self::Vuv),
            b"WST" => Ok(Self::Wst),
            b"YDD" => Ok(Self::Ydd),
            b"YER" => Ok(Self::Yer),
            b"YUD" => Ok(Self::Yud),
            b"ZAR" => Ok(Self::Zar),
            b"ZMK" => Ok(Self::Zmk),
            b"ZRZ" => Ok(Self::Zrz),
            b"ZWD" => Ok(Self::Zwd),
            x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
                RawByteStr::from_slice(x),
            ))),
        }
    }
}
impl WithDeserializerFromBytes for DtCurrencies {}
#[derive(Debug)]
pub struct TypePartyId {
    pub type_: Option<String>,
    pub content: String,
}
impl WithSerializer for TypePartyId {
    type Serializer<'x> = quick_xml_serialize::TypePartyIdSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::TypePartyIdSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::TypePartyIdSerializerState::Init__),
            name: name.unwrap_or("typePARTY_ID"),
            is_root,
        })
    }
}
impl WithDeserializer for TypePartyId {
    type Deserializer = quick_xml_deserialize::TypePartyIdDeserializer;
}
#[derive(Debug)]
pub struct SupplierAddressElementType {
    pub type_: SupplierAddressType,
    pub contact: Vec<DtMlstring>,
    pub street: Vec<DtMlstring>,
    pub zip: Vec<DtMlstring>,
    pub city: Vec<DtMlstring>,
    pub country: Vec<DtMlstring>,
    pub vat_id: Option<String>,
    pub email: String,
    pub url: Option<String>,
}
impl WithSerializer for SupplierAddressElementType {
    type Serializer<'x> = quick_xml_serialize::SupplierAddressElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::SupplierAddressElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::SupplierAddressElementTypeSerializerState::Init__),
            name: name.unwrap_or("SupplierAddress"),
            is_root,
        })
    }
}
impl WithDeserializer for SupplierAddressElementType {
    type Deserializer = quick_xml_deserialize::SupplierAddressElementTypeDeserializer;
}
#[derive(Debug)]
pub struct MimeInfoElementType {
    pub mime: Vec<MimeElementType>,
}
impl WithSerializer for MimeInfoElementType {
    type Serializer<'x> = quick_xml_serialize::MimeInfoElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::MimeInfoElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::MimeInfoElementTypeSerializerState::Init__),
            name: name.unwrap_or("MIME_INFO"),
            is_root,
        })
    }
}
impl WithDeserializer for MimeInfoElementType {
    type Deserializer = quick_xml_deserialize::MimeInfoElementTypeDeserializer;
}
#[derive(Debug)]
pub enum TNewCatalogProductMode {
    New,
}
impl SerializeBytes for TNewCatalogProductMode {
    fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
        match self {
            Self::New => Ok(Some(Cow::Borrowed("new"))),
        }
    }
}
impl WithSerializeToBytes for TNewCatalogProductMode {}
impl DeserializeBytes for TNewCatalogProductMode {
    fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
        match bytes {
            b"new" => Ok(Self::New),
            x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
                RawByteStr::from_slice(x),
            ))),
        }
    }
}
impl WithDeserializerFromBytes for TNewCatalogProductMode {}
#[derive(Debug)]
pub struct SupplierPidElementType {
    pub type_: Option<String>,
    pub content: String,
}
impl WithSerializer for SupplierPidElementType {
    type Serializer<'x> = quick_xml_serialize::SupplierPidElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::SupplierPidElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::SupplierPidElementTypeSerializerState::Init__),
            name: name.unwrap_or("SUPPLIER_PID"),
            is_root,
        })
    }
}
impl WithDeserializer for SupplierPidElementType {
    type Deserializer = quick_xml_deserialize::SupplierPidElementTypeDeserializer;
}
#[derive(Debug)]
pub struct ProductDetailsElementType {
    pub description_short: Vec<DtMlstring>,
    pub description_long: Vec<DtMlstring>,
    pub international_pid: Vec<InternationalPidElementType>,
    pub supplier_alt_pid: Option<String>,
    pub buyer_pid: Vec<BuyerPidElementType>,
    pub manufacturer_pid: Option<String>,
    pub manufacturer_name: Option<String>,
    pub manufacturer_type_descr: Vec<DtMlstring>,
    pub special_treatment_class: Vec<SpecialTreatmentClassElementType>,
    pub keyword: Vec<DtMlstring>,
    pub remarks: Vec<RemarksElementType>,
    pub product_status: Vec<ProductStatusElementType>,
}
impl WithSerializer for ProductDetailsElementType {
    type Serializer<'x> = quick_xml_serialize::ProductDetailsElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::ProductDetailsElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::ProductDetailsElementTypeSerializerState::Init__),
            name: name.unwrap_or("PRODUCT_DETAILS"),
            is_root,
        })
    }
}
impl WithDeserializer for ProductDetailsElementType {
    type Deserializer = quick_xml_deserialize::ProductDetailsElementTypeDeserializer;
}
#[derive(Debug)]
pub struct ProductFeaturesElementType {
    pub reference_feature_system_name: String,
    pub reference_feature_group_id: TypeClassificationGroupId,
    pub feature: Vec<FeatureElementType>,
}
impl WithSerializer for ProductFeaturesElementType {
    type Serializer<'x> = quick_xml_serialize::ProductFeaturesElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::ProductFeaturesElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::ProductFeaturesElementTypeSerializerState::Init__),
            name: name.unwrap_or("PRODUCT_FEATURES"),
            is_root,
        })
    }
}
impl WithDeserializer for ProductFeaturesElementType {
    type Deserializer = quick_xml_deserialize::ProductFeaturesElementTypeDeserializer;
}
#[derive(Debug)]
pub struct ProductOrderDetailsElementType {
    pub order_unit: DtPunit,
    pub content_unit: DtPunit,
    pub no_cu_per_ou: Option<f64>,
    pub price_quantity: Option<f64>,
    pub quantity_min: Option<f32>,
    pub quantity_interval: Option<f32>,
}
impl WithSerializer for ProductOrderDetailsElementType {
    type Serializer<'x> = quick_xml_serialize::ProductOrderDetailsElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(
            quick_xml_serialize::ProductOrderDetailsElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::ProductOrderDetailsElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("PRODUCT_ORDER_DETAILS"),
                is_root,
            },
        )
    }
}
impl WithDeserializer for ProductOrderDetailsElementType {
    type Deserializer = quick_xml_deserialize::ProductOrderDetailsElementTypeDeserializer;
}
#[derive(Debug)]
pub struct ProductPriceDetailsElementType {
    pub datetime: Vec<ProductPriceDetailsDatetimeElementType>,
    pub daily_price: Option<String>,
    pub product_price: Vec<ProductPriceElementType>,
}
impl WithSerializer for ProductPriceDetailsElementType {
    type Serializer<'x> = quick_xml_serialize::ProductPriceDetailsElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(
            quick_xml_serialize::ProductPriceDetailsElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::ProductPriceDetailsElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("PRODUCT_PRICE_DETAILS"),
                is_root,
            },
        )
    }
}
impl WithDeserializer for ProductPriceDetailsElementType {
    type Deserializer = quick_xml_deserialize::ProductPriceDetailsElementTypeDeserializer;
}
#[derive(Debug)]
pub struct UdxProduct {
    pub udx_edxf_manufacturer_acronym: Option<String>,
    pub udx_edxf_description_very_short: Vec<DtMlstring>,
    pub udx_edxf_brand_name: Option<String>,
    pub udx_edxf_tender_text: Vec<DtMlstring>,
    pub udx_edxf_valid_from: Option<String>,
    pub udx_edxf_expiration_date: Option<String>,
    pub udx_edxf_discount_group: Option<UdxEdxfDiscountGroupElementType>,
    pub udx_edxf_bonus_group_supplier: Option<String>,
    pub udx_edxf_pkwiu: Option<String>,
    pub udx_edxf_declaration: Vec<UdxEdxfDeclarationElementType>,
    pub udx_edxf_additional_factors: Option<UdxEdxfAdditionalFactorsElementType>,
    pub udx_edxf_product_to_stock: Option<String>,
    pub udx_edxf_product_series: Vec<DtMlstring>,
    pub udx_edxf_product_variation: Vec<DtMlstring>,
    pub udx_edxf_at_reverse_charge_info: Option<String>,
    pub udx_edxf_country_branch_numbers: Option<UdxEdxfCountryBranchNumbersElementType>,
    pub udx_edxf_country_branch_supplier_ids: Option<UdxEdxfCountryBranchSupplierIdsElementType>,
    pub udx_edxf_packing_units: Option<UdxEdxfPackingUnitsElementType>,
    pub udx_edxf_product_logistic_details: Option<UdxEdxfProductLogisticDetailsElementType>,
    pub udx_edxf_reach: Option<UdxEdxfReachElementType>,
    pub udx_edxf_surcharge_list: Option<UdxEdxfSurchargeListElementType>,
}
impl WithSerializer for UdxProduct {
    type Serializer<'x> = quick_xml_serialize::UdxProductSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::UdxProductSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::UdxProductSerializerState::Init__),
            name: name.unwrap_or("udxPRODUCT"),
            is_root,
        })
    }
}
impl WithDeserializer for UdxProduct {
    type Deserializer = quick_xml_deserialize::UdxProductDeserializer;
}
#[derive(Debug)]
pub struct ProductReferenceElementType {
    pub type_: ProductReferenceType,
    pub quantity: Option<i32>,
    pub prod_id_to: String,
    pub catalog_id: Option<String>,
    pub catalog_version: Option<String>,
}
impl WithSerializer for ProductReferenceElementType {
    type Serializer<'x> = quick_xml_serialize::ProductReferenceElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::ProductReferenceElementTypeSerializer {
            value: self,
            state: Box::new(
                quick_xml_serialize::ProductReferenceElementTypeSerializerState::Init__,
            ),
            name: name.unwrap_or("PRODUCT_REFERENCE"),
            is_root,
        })
    }
}
impl WithDeserializer for ProductReferenceElementType {
    type Deserializer = quick_xml_deserialize::ProductReferenceElementTypeDeserializer;
}
#[derive(Debug)]
pub struct ProductLogisticDetailsElementType {
    pub customs_tariff_number: Vec<CustomsTariffNumberElementType>,
    pub statistics_factor: Option<f64>,
    pub country_of_origin: Vec<String>,
}
impl WithSerializer for ProductLogisticDetailsElementType {
    type Serializer<'x> = quick_xml_serialize::ProductLogisticDetailsElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(
            quick_xml_serialize::ProductLogisticDetailsElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::ProductLogisticDetailsElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("PRODUCT_LOGISTIC_DETAILS"),
                is_root,
            },
        )
    }
}
impl WithDeserializer for ProductLogisticDetailsElementType {
    type Deserializer = quick_xml_deserialize::ProductLogisticDetailsElementTypeDeserializer;
}
#[derive(Debug)]
pub enum TUpdateProductsProductMode {
    Delete,
    New,
    Update,
}
impl SerializeBytes for TUpdateProductsProductMode {
    fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
        match self {
            Self::Delete => Ok(Some(Cow::Borrowed("delete"))),
            Self::New => Ok(Some(Cow::Borrowed("new"))),
            Self::Update => Ok(Some(Cow::Borrowed("update"))),
        }
    }
}
impl WithSerializeToBytes for TUpdateProductsProductMode {}
impl DeserializeBytes for TUpdateProductsProductMode {
    fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
        match bytes {
            b"delete" => Ok(Self::Delete),
            b"new" => Ok(Self::New),
            b"update" => Ok(Self::Update),
            x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
                RawByteStr::from_slice(x),
            ))),
        }
    }
}
impl WithDeserializerFromBytes for TUpdateProductsProductMode {}
#[derive(Debug)]
pub enum TUpdatePricesProductMode {
    Update,
}
impl SerializeBytes for TUpdatePricesProductMode {
    fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
        match self {
            Self::Update => Ok(Some(Cow::Borrowed("update"))),
        }
    }
}
impl WithSerializeToBytes for TUpdatePricesProductMode {}
impl DeserializeBytes for TUpdatePricesProductMode {
    fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
        match bytes {
            b"update" => Ok(Self::Update),
            x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
                RawByteStr::from_slice(x),
            ))),
        }
    }
}
impl WithDeserializerFromBytes for TUpdatePricesProductMode {}
#[derive(Debug)]
pub enum DtLang {
    Aar,
    Abk,
    Ace,
    Ach,
    Ada,
    Afa,
    Afh,
    Afr,
    Aka,
    Akk,
    Alb,
    Ale,
    Alg,
    Amh,
    Ang,
    Apa,
    Ara,
    Arc,
    Arm,
    Arn,
    Arp,
    Art,
    Arw,
    Asm,
    Ath,
    Aus,
    Ava,
    Ave,
    Awa,
    Aym,
    Aze,
    Bad,
    Bai,
    Bak,
    Bal,
    Bam,
    Ban,
    Baq,
    Bas,
    Bat,
    Bej,
    Bel,
    Bem,
    Ben,
    Ber,
    Bho,
    Bih,
    Bik,
    Bin,
    Bis,
    Bla,
    Bnt,
    Bod,
    Bos,
    Bra,
    Bre,
    Btk,
    Bua,
    Bug,
    Bul,
    Bur,
    Cad,
    Cai,
    Car,
    Cat,
    Cau,
    Ceb,
    Cel,
    Ces,
    Cha,
    Chb,
    Che,
    Chg,
    Chi,
    Chk,
    Chm,
    Chn,
    Cho,
    Chp,
    Chr,
    Chu,
    Chv,
    Chy,
    Cmc,
    Cop,
    Cor,
    Cos,
    Cpe,
    Cpf,
    Cpp,
    Cre,
    Crp,
    Cus,
    Cym,
    Cze,
    Dak,
    Dan,
    Day,
    Del,
    Den,
    Deu,
    Dgr,
    Din,
    Div,
    Doi,
    Dra,
    Dua,
    Dum,
    Dut,
    Dyu,
    Dzo,
    Efi,
    Egy,
    Eka,
    Ell,
    Elx,
    Eng,
    Enm,
    Epo,
    Est,
    Eus,
    Ewe,
    Ewo,
    Fan,
    Fao,
    Fas,
    Fat,
    Fij,
    Fin,
    Fiu,
    Fon,
    Fra,
    Fre,
    Frm,
    Fro,
    Fry,
    Ful,
    Fur,
    Gaa,
    Gay,
    Gba,
    Gem,
    Geo,
    Ger,
    Gez,
    Gil,
    Gla,
    Gle,
    Glg,
    Glv,
    Gmh,
    Goh,
    Gon,
    Gor,
    Got,
    Grb,
    Grc,
    Gre,
    Grn,
    Guj,
    Gwi,
    Hai,
    Hau,
    Haw,
    Heb,
    Her,
    Hil,
    Him,
    Hin,
    Hit,
    Hmn,
    Hmo,
    Hrv,
    Hun,
    Hup,
    Hye,
    Iba,
    Ibo,
    Ice,
    Ijo,
    Iku,
    Ile,
    Ilo,
    Ina,
    Inc,
    Ind,
    Ine,
    Ipk,
    Ira,
    Iro,
    Isl,
    Ita,
    Jav,
    Jpn,
    Jpr,
    Jrb,
    Kaa,
    Kab,
    Kac,
    Kal,
    Kam,
    Kan,
    Kar,
    Kas,
    Kat,
    Kau,
    Kaw,
    Kaz,
    Kha,
    Khi,
    Khm,
    Kho,
    Kik,
    Kin,
    Kir,
    Kmb,
    Kok,
    Kom,
    Kon,
    Kor,
    Kos,
    Kpe,
    Kro,
    Kru,
    Kua,
    Kum,
    Kur,
    Kut,
    Lad,
    Lah,
    Lam,
    Lao,
    Lat,
    Lav,
    Lez,
    Lin,
    Lit,
    Lol,
    Loz,
    Ltz,
    Lua,
    Lub,
    Lug,
    Lui,
    Lun,
    Luo,
    Lus,
    Mac,
    Mad,
    Mag,
    Mah,
    Mai,
    Mak,
    Mal,
    Man,
    Mao,
    Map,
    Mar,
    Mas,
    May,
    Mdr,
    Men,
    Mga,
    Mic,
    Min,
    Mis,
    Mkd,
    Mkh,
    Mlg,
    Mlt,
    Mnc,
    Mni,
    Mno,
    Moh,
    Mol,
    Mon,
    Mos,
    Mri,
    Msa,
    Mul,
    Mun,
    Mus,
    Mwr,
    Mya,
    Myn,
    Nah,
    Nai,
    Nau,
    Nav,
    Nbl,
    Nde,
    Ndo,
    Nds,
    Nep,
    New,
    Nia,
    Nic,
    Niu,
    Nld,
    Nno,
    Nob,
    Non,
    Nor,
    Nso,
    Nub,
    Nya,
    Nym,
    Nyn,
    Nyo,
    Nzi,
    Oci,
    Oji,
    Ori,
    Orm,
    Osa,
    Oss,
    Ota,
    Oto,
    Paa,
    Pag,
    Pal,
    Pam,
    Pan,
    Pap,
    Pau,
    Peo,
    Per,
    Phi,
    Phn,
    Pli,
    Pol,
    Pon,
    Por,
    Pra,
    Pro,
    Pus,
    Qaa,
    Que,
    Raj,
    Rap,
    Rar,
    Roa,
    Roh,
    Rom,
    Ron,
    Rum,
    Run,
    Rus,
    Sad,
    Sag,
    Sah,
    Sai,
    Sal,
    Sam,
    San,
    Sas,
    Sat,
    Scc,
    Sco,
    Scr,
    Sel,
    Sem,
    Sga,
    Sgn,
    Shn,
    Sid,
    Sin,
    Sio,
    Sit,
    Sla,
    Slk,
    Slo,
    Slv,
    Sme,
    Smi,
    Smo,
    Sna,
    Snd,
    Snk,
    Sog,
    Som,
    Son,
    Sot,
    Spa,
    Sqi,
    Srd,
    Srp,
    Srr,
    Ssa,
    Ssw,
    Suk,
    Sun,
    Sus,
    Sux,
    Swa,
    Swe,
    Syr,
    Tah,
    Tai,
    Tam,
    Tat,
    Tel,
    Tem,
    Ter,
    Tet,
    Tgk,
    Tgl,
    Tha,
    Tib,
    Tig,
    Tir,
    Tiv,
    Tkl,
    Tli,
    Tmh,
    Tog,
    Ton,
    Tpi,
    Tsi,
    Tsn,
    Tso,
    Tuk,
    Tum,
    Tur,
    Tut,
    Tvl,
    Twi,
    Tyv,
    Uga,
    Uig,
    Ukr,
    Umb,
    Und,
    Urd,
    Uzb,
    Vai,
    Ven,
    Vie,
    Vol,
    Vot,
    Wak,
    Wal,
    War,
    Was,
    Wel,
    Wen,
    Wol,
    Xho,
    Yao,
    Yap,
    Yid,
    Yor,
    Ypk,
    Zap,
    Zen,
    Zha,
    Zho,
    Znd,
    Zul,
}
impl SerializeBytes for DtLang {
    fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
        match self {
            Self::Aar => Ok(Some(Cow::Borrowed("aar"))),
            Self::Abk => Ok(Some(Cow::Borrowed("abk"))),
            Self::Ace => Ok(Some(Cow::Borrowed("ace"))),
            Self::Ach => Ok(Some(Cow::Borrowed("ach"))),
            Self::Ada => Ok(Some(Cow::Borrowed("ada"))),
            Self::Afa => Ok(Some(Cow::Borrowed("afa"))),
            Self::Afh => Ok(Some(Cow::Borrowed("afh"))),
            Self::Afr => Ok(Some(Cow::Borrowed("afr"))),
            Self::Aka => Ok(Some(Cow::Borrowed("aka"))),
            Self::Akk => Ok(Some(Cow::Borrowed("akk"))),
            Self::Alb => Ok(Some(Cow::Borrowed("alb"))),
            Self::Ale => Ok(Some(Cow::Borrowed("ale"))),
            Self::Alg => Ok(Some(Cow::Borrowed("alg"))),
            Self::Amh => Ok(Some(Cow::Borrowed("amh"))),
            Self::Ang => Ok(Some(Cow::Borrowed("ang"))),
            Self::Apa => Ok(Some(Cow::Borrowed("apa"))),
            Self::Ara => Ok(Some(Cow::Borrowed("ara"))),
            Self::Arc => Ok(Some(Cow::Borrowed("arc"))),
            Self::Arm => Ok(Some(Cow::Borrowed("arm"))),
            Self::Arn => Ok(Some(Cow::Borrowed("arn"))),
            Self::Arp => Ok(Some(Cow::Borrowed("arp"))),
            Self::Art => Ok(Some(Cow::Borrowed("art"))),
            Self::Arw => Ok(Some(Cow::Borrowed("arw"))),
            Self::Asm => Ok(Some(Cow::Borrowed("asm"))),
            Self::Ath => Ok(Some(Cow::Borrowed("ath"))),
            Self::Aus => Ok(Some(Cow::Borrowed("aus"))),
            Self::Ava => Ok(Some(Cow::Borrowed("ava"))),
            Self::Ave => Ok(Some(Cow::Borrowed("ave"))),
            Self::Awa => Ok(Some(Cow::Borrowed("awa"))),
            Self::Aym => Ok(Some(Cow::Borrowed("aym"))),
            Self::Aze => Ok(Some(Cow::Borrowed("aze"))),
            Self::Bad => Ok(Some(Cow::Borrowed("bad"))),
            Self::Bai => Ok(Some(Cow::Borrowed("bai"))),
            Self::Bak => Ok(Some(Cow::Borrowed("bak"))),
            Self::Bal => Ok(Some(Cow::Borrowed("bal"))),
            Self::Bam => Ok(Some(Cow::Borrowed("bam"))),
            Self::Ban => Ok(Some(Cow::Borrowed("ban"))),
            Self::Baq => Ok(Some(Cow::Borrowed("baq"))),
            Self::Bas => Ok(Some(Cow::Borrowed("bas"))),
            Self::Bat => Ok(Some(Cow::Borrowed("bat"))),
            Self::Bej => Ok(Some(Cow::Borrowed("bej"))),
            Self::Bel => Ok(Some(Cow::Borrowed("bel"))),
            Self::Bem => Ok(Some(Cow::Borrowed("bem"))),
            Self::Ben => Ok(Some(Cow::Borrowed("ben"))),
            Self::Ber => Ok(Some(Cow::Borrowed("ber"))),
            Self::Bho => Ok(Some(Cow::Borrowed("bho"))),
            Self::Bih => Ok(Some(Cow::Borrowed("bih"))),
            Self::Bik => Ok(Some(Cow::Borrowed("bik"))),
            Self::Bin => Ok(Some(Cow::Borrowed("bin"))),
            Self::Bis => Ok(Some(Cow::Borrowed("bis"))),
            Self::Bla => Ok(Some(Cow::Borrowed("bla"))),
            Self::Bnt => Ok(Some(Cow::Borrowed("bnt"))),
            Self::Bod => Ok(Some(Cow::Borrowed("bod"))),
            Self::Bos => Ok(Some(Cow::Borrowed("bos"))),
            Self::Bra => Ok(Some(Cow::Borrowed("bra"))),
            Self::Bre => Ok(Some(Cow::Borrowed("bre"))),
            Self::Btk => Ok(Some(Cow::Borrowed("btk"))),
            Self::Bua => Ok(Some(Cow::Borrowed("bua"))),
            Self::Bug => Ok(Some(Cow::Borrowed("bug"))),
            Self::Bul => Ok(Some(Cow::Borrowed("bul"))),
            Self::Bur => Ok(Some(Cow::Borrowed("bur"))),
            Self::Cad => Ok(Some(Cow::Borrowed("cad"))),
            Self::Cai => Ok(Some(Cow::Borrowed("cai"))),
            Self::Car => Ok(Some(Cow::Borrowed("car"))),
            Self::Cat => Ok(Some(Cow::Borrowed("cat"))),
            Self::Cau => Ok(Some(Cow::Borrowed("cau"))),
            Self::Ceb => Ok(Some(Cow::Borrowed("ceb"))),
            Self::Cel => Ok(Some(Cow::Borrowed("cel"))),
            Self::Ces => Ok(Some(Cow::Borrowed("ces"))),
            Self::Cha => Ok(Some(Cow::Borrowed("cha"))),
            Self::Chb => Ok(Some(Cow::Borrowed("chb"))),
            Self::Che => Ok(Some(Cow::Borrowed("che"))),
            Self::Chg => Ok(Some(Cow::Borrowed("chg"))),
            Self::Chi => Ok(Some(Cow::Borrowed("chi"))),
            Self::Chk => Ok(Some(Cow::Borrowed("chk"))),
            Self::Chm => Ok(Some(Cow::Borrowed("chm"))),
            Self::Chn => Ok(Some(Cow::Borrowed("chn"))),
            Self::Cho => Ok(Some(Cow::Borrowed("cho"))),
            Self::Chp => Ok(Some(Cow::Borrowed("chp"))),
            Self::Chr => Ok(Some(Cow::Borrowed("chr"))),
            Self::Chu => Ok(Some(Cow::Borrowed("chu"))),
            Self::Chv => Ok(Some(Cow::Borrowed("chv"))),
            Self::Chy => Ok(Some(Cow::Borrowed("chy"))),
            Self::Cmc => Ok(Some(Cow::Borrowed("cmc"))),
            Self::Cop => Ok(Some(Cow::Borrowed("cop"))),
            Self::Cor => Ok(Some(Cow::Borrowed("cor"))),
            Self::Cos => Ok(Some(Cow::Borrowed("cos"))),
            Self::Cpe => Ok(Some(Cow::Borrowed("cpe"))),
            Self::Cpf => Ok(Some(Cow::Borrowed("cpf"))),
            Self::Cpp => Ok(Some(Cow::Borrowed("cpp"))),
            Self::Cre => Ok(Some(Cow::Borrowed("cre"))),
            Self::Crp => Ok(Some(Cow::Borrowed("crp"))),
            Self::Cus => Ok(Some(Cow::Borrowed("cus"))),
            Self::Cym => Ok(Some(Cow::Borrowed("cym"))),
            Self::Cze => Ok(Some(Cow::Borrowed("cze"))),
            Self::Dak => Ok(Some(Cow::Borrowed("dak"))),
            Self::Dan => Ok(Some(Cow::Borrowed("dan"))),
            Self::Day => Ok(Some(Cow::Borrowed("day"))),
            Self::Del => Ok(Some(Cow::Borrowed("del"))),
            Self::Den => Ok(Some(Cow::Borrowed("den"))),
            Self::Deu => Ok(Some(Cow::Borrowed("deu"))),
            Self::Dgr => Ok(Some(Cow::Borrowed("dgr"))),
            Self::Din => Ok(Some(Cow::Borrowed("din"))),
            Self::Div => Ok(Some(Cow::Borrowed("div"))),
            Self::Doi => Ok(Some(Cow::Borrowed("doi"))),
            Self::Dra => Ok(Some(Cow::Borrowed("dra"))),
            Self::Dua => Ok(Some(Cow::Borrowed("dua"))),
            Self::Dum => Ok(Some(Cow::Borrowed("dum"))),
            Self::Dut => Ok(Some(Cow::Borrowed("dut"))),
            Self::Dyu => Ok(Some(Cow::Borrowed("dyu"))),
            Self::Dzo => Ok(Some(Cow::Borrowed("dzo"))),
            Self::Efi => Ok(Some(Cow::Borrowed("efi"))),
            Self::Egy => Ok(Some(Cow::Borrowed("egy"))),
            Self::Eka => Ok(Some(Cow::Borrowed("eka"))),
            Self::Ell => Ok(Some(Cow::Borrowed("ell"))),
            Self::Elx => Ok(Some(Cow::Borrowed("elx"))),
            Self::Eng => Ok(Some(Cow::Borrowed("eng"))),
            Self::Enm => Ok(Some(Cow::Borrowed("enm"))),
            Self::Epo => Ok(Some(Cow::Borrowed("epo"))),
            Self::Est => Ok(Some(Cow::Borrowed("est"))),
            Self::Eus => Ok(Some(Cow::Borrowed("eus"))),
            Self::Ewe => Ok(Some(Cow::Borrowed("ewe"))),
            Self::Ewo => Ok(Some(Cow::Borrowed("ewo"))),
            Self::Fan => Ok(Some(Cow::Borrowed("fan"))),
            Self::Fao => Ok(Some(Cow::Borrowed("fao"))),
            Self::Fas => Ok(Some(Cow::Borrowed("fas"))),
            Self::Fat => Ok(Some(Cow::Borrowed("fat"))),
            Self::Fij => Ok(Some(Cow::Borrowed("fij"))),
            Self::Fin => Ok(Some(Cow::Borrowed("fin"))),
            Self::Fiu => Ok(Some(Cow::Borrowed("fiu"))),
            Self::Fon => Ok(Some(Cow::Borrowed("fon"))),
            Self::Fra => Ok(Some(Cow::Borrowed("fra"))),
            Self::Fre => Ok(Some(Cow::Borrowed("fre"))),
            Self::Frm => Ok(Some(Cow::Borrowed("frm"))),
            Self::Fro => Ok(Some(Cow::Borrowed("fro"))),
            Self::Fry => Ok(Some(Cow::Borrowed("fry"))),
            Self::Ful => Ok(Some(Cow::Borrowed("ful"))),
            Self::Fur => Ok(Some(Cow::Borrowed("fur"))),
            Self::Gaa => Ok(Some(Cow::Borrowed("gaa"))),
            Self::Gay => Ok(Some(Cow::Borrowed("gay"))),
            Self::Gba => Ok(Some(Cow::Borrowed("gba"))),
            Self::Gem => Ok(Some(Cow::Borrowed("gem"))),
            Self::Geo => Ok(Some(Cow::Borrowed("geo"))),
            Self::Ger => Ok(Some(Cow::Borrowed("ger"))),
            Self::Gez => Ok(Some(Cow::Borrowed("gez"))),
            Self::Gil => Ok(Some(Cow::Borrowed("gil"))),
            Self::Gla => Ok(Some(Cow::Borrowed("gla"))),
            Self::Gle => Ok(Some(Cow::Borrowed("gle"))),
            Self::Glg => Ok(Some(Cow::Borrowed("glg"))),
            Self::Glv => Ok(Some(Cow::Borrowed("glv"))),
            Self::Gmh => Ok(Some(Cow::Borrowed("gmh"))),
            Self::Goh => Ok(Some(Cow::Borrowed("goh"))),
            Self::Gon => Ok(Some(Cow::Borrowed("gon"))),
            Self::Gor => Ok(Some(Cow::Borrowed("gor"))),
            Self::Got => Ok(Some(Cow::Borrowed("got"))),
            Self::Grb => Ok(Some(Cow::Borrowed("grb"))),
            Self::Grc => Ok(Some(Cow::Borrowed("grc"))),
            Self::Gre => Ok(Some(Cow::Borrowed("gre"))),
            Self::Grn => Ok(Some(Cow::Borrowed("grn"))),
            Self::Guj => Ok(Some(Cow::Borrowed("guj"))),
            Self::Gwi => Ok(Some(Cow::Borrowed("gwi"))),
            Self::Hai => Ok(Some(Cow::Borrowed("hai"))),
            Self::Hau => Ok(Some(Cow::Borrowed("hau"))),
            Self::Haw => Ok(Some(Cow::Borrowed("haw"))),
            Self::Heb => Ok(Some(Cow::Borrowed("heb"))),
            Self::Her => Ok(Some(Cow::Borrowed("her"))),
            Self::Hil => Ok(Some(Cow::Borrowed("hil"))),
            Self::Him => Ok(Some(Cow::Borrowed("him"))),
            Self::Hin => Ok(Some(Cow::Borrowed("hin"))),
            Self::Hit => Ok(Some(Cow::Borrowed("hit"))),
            Self::Hmn => Ok(Some(Cow::Borrowed("hmn"))),
            Self::Hmo => Ok(Some(Cow::Borrowed("hmo"))),
            Self::Hrv => Ok(Some(Cow::Borrowed("hrv"))),
            Self::Hun => Ok(Some(Cow::Borrowed("hun"))),
            Self::Hup => Ok(Some(Cow::Borrowed("hup"))),
            Self::Hye => Ok(Some(Cow::Borrowed("hye"))),
            Self::Iba => Ok(Some(Cow::Borrowed("iba"))),
            Self::Ibo => Ok(Some(Cow::Borrowed("ibo"))),
            Self::Ice => Ok(Some(Cow::Borrowed("ice"))),
            Self::Ijo => Ok(Some(Cow::Borrowed("ijo"))),
            Self::Iku => Ok(Some(Cow::Borrowed("iku"))),
            Self::Ile => Ok(Some(Cow::Borrowed("ile"))),
            Self::Ilo => Ok(Some(Cow::Borrowed("ilo"))),
            Self::Ina => Ok(Some(Cow::Borrowed("ina"))),
            Self::Inc => Ok(Some(Cow::Borrowed("inc"))),
            Self::Ind => Ok(Some(Cow::Borrowed("ind"))),
            Self::Ine => Ok(Some(Cow::Borrowed("ine"))),
            Self::Ipk => Ok(Some(Cow::Borrowed("ipk"))),
            Self::Ira => Ok(Some(Cow::Borrowed("ira"))),
            Self::Iro => Ok(Some(Cow::Borrowed("iro"))),
            Self::Isl => Ok(Some(Cow::Borrowed("isl"))),
            Self::Ita => Ok(Some(Cow::Borrowed("ita"))),
            Self::Jav => Ok(Some(Cow::Borrowed("jav"))),
            Self::Jpn => Ok(Some(Cow::Borrowed("jpn"))),
            Self::Jpr => Ok(Some(Cow::Borrowed("jpr"))),
            Self::Jrb => Ok(Some(Cow::Borrowed("jrb"))),
            Self::Kaa => Ok(Some(Cow::Borrowed("kaa"))),
            Self::Kab => Ok(Some(Cow::Borrowed("kab"))),
            Self::Kac => Ok(Some(Cow::Borrowed("kac"))),
            Self::Kal => Ok(Some(Cow::Borrowed("kal"))),
            Self::Kam => Ok(Some(Cow::Borrowed("kam"))),
            Self::Kan => Ok(Some(Cow::Borrowed("kan"))),
            Self::Kar => Ok(Some(Cow::Borrowed("kar"))),
            Self::Kas => Ok(Some(Cow::Borrowed("kas"))),
            Self::Kat => Ok(Some(Cow::Borrowed("kat"))),
            Self::Kau => Ok(Some(Cow::Borrowed("kau"))),
            Self::Kaw => Ok(Some(Cow::Borrowed("kaw"))),
            Self::Kaz => Ok(Some(Cow::Borrowed("kaz"))),
            Self::Kha => Ok(Some(Cow::Borrowed("kha"))),
            Self::Khi => Ok(Some(Cow::Borrowed("khi"))),
            Self::Khm => Ok(Some(Cow::Borrowed("khm"))),
            Self::Kho => Ok(Some(Cow::Borrowed("kho"))),
            Self::Kik => Ok(Some(Cow::Borrowed("kik"))),
            Self::Kin => Ok(Some(Cow::Borrowed("kin"))),
            Self::Kir => Ok(Some(Cow::Borrowed("kir"))),
            Self::Kmb => Ok(Some(Cow::Borrowed("kmb"))),
            Self::Kok => Ok(Some(Cow::Borrowed("kok"))),
            Self::Kom => Ok(Some(Cow::Borrowed("kom"))),
            Self::Kon => Ok(Some(Cow::Borrowed("kon"))),
            Self::Kor => Ok(Some(Cow::Borrowed("kor"))),
            Self::Kos => Ok(Some(Cow::Borrowed("kos"))),
            Self::Kpe => Ok(Some(Cow::Borrowed("kpe"))),
            Self::Kro => Ok(Some(Cow::Borrowed("kro"))),
            Self::Kru => Ok(Some(Cow::Borrowed("kru"))),
            Self::Kua => Ok(Some(Cow::Borrowed("kua"))),
            Self::Kum => Ok(Some(Cow::Borrowed("kum"))),
            Self::Kur => Ok(Some(Cow::Borrowed("kur"))),
            Self::Kut => Ok(Some(Cow::Borrowed("kut"))),
            Self::Lad => Ok(Some(Cow::Borrowed("lad"))),
            Self::Lah => Ok(Some(Cow::Borrowed("lah"))),
            Self::Lam => Ok(Some(Cow::Borrowed("lam"))),
            Self::Lao => Ok(Some(Cow::Borrowed("lao"))),
            Self::Lat => Ok(Some(Cow::Borrowed("lat"))),
            Self::Lav => Ok(Some(Cow::Borrowed("lav"))),
            Self::Lez => Ok(Some(Cow::Borrowed("lez"))),
            Self::Lin => Ok(Some(Cow::Borrowed("lin"))),
            Self::Lit => Ok(Some(Cow::Borrowed("lit"))),
            Self::Lol => Ok(Some(Cow::Borrowed("lol"))),
            Self::Loz => Ok(Some(Cow::Borrowed("loz"))),
            Self::Ltz => Ok(Some(Cow::Borrowed("ltz"))),
            Self::Lua => Ok(Some(Cow::Borrowed("lua"))),
            Self::Lub => Ok(Some(Cow::Borrowed("lub"))),
            Self::Lug => Ok(Some(Cow::Borrowed("lug"))),
            Self::Lui => Ok(Some(Cow::Borrowed("lui"))),
            Self::Lun => Ok(Some(Cow::Borrowed("lun"))),
            Self::Luo => Ok(Some(Cow::Borrowed("luo"))),
            Self::Lus => Ok(Some(Cow::Borrowed("lus"))),
            Self::Mac => Ok(Some(Cow::Borrowed("mac"))),
            Self::Mad => Ok(Some(Cow::Borrowed("mad"))),
            Self::Mag => Ok(Some(Cow::Borrowed("mag"))),
            Self::Mah => Ok(Some(Cow::Borrowed("mah"))),
            Self::Mai => Ok(Some(Cow::Borrowed("mai"))),
            Self::Mak => Ok(Some(Cow::Borrowed("mak"))),
            Self::Mal => Ok(Some(Cow::Borrowed("mal"))),
            Self::Man => Ok(Some(Cow::Borrowed("man"))),
            Self::Mao => Ok(Some(Cow::Borrowed("mao"))),
            Self::Map => Ok(Some(Cow::Borrowed("map"))),
            Self::Mar => Ok(Some(Cow::Borrowed("mar"))),
            Self::Mas => Ok(Some(Cow::Borrowed("mas"))),
            Self::May => Ok(Some(Cow::Borrowed("may"))),
            Self::Mdr => Ok(Some(Cow::Borrowed("mdr"))),
            Self::Men => Ok(Some(Cow::Borrowed("men"))),
            Self::Mga => Ok(Some(Cow::Borrowed("mga"))),
            Self::Mic => Ok(Some(Cow::Borrowed("mic"))),
            Self::Min => Ok(Some(Cow::Borrowed("min"))),
            Self::Mis => Ok(Some(Cow::Borrowed("mis"))),
            Self::Mkd => Ok(Some(Cow::Borrowed("mkd"))),
            Self::Mkh => Ok(Some(Cow::Borrowed("mkh"))),
            Self::Mlg => Ok(Some(Cow::Borrowed("mlg"))),
            Self::Mlt => Ok(Some(Cow::Borrowed("mlt"))),
            Self::Mnc => Ok(Some(Cow::Borrowed("mnc"))),
            Self::Mni => Ok(Some(Cow::Borrowed("mni"))),
            Self::Mno => Ok(Some(Cow::Borrowed("mno"))),
            Self::Moh => Ok(Some(Cow::Borrowed("moh"))),
            Self::Mol => Ok(Some(Cow::Borrowed("mol"))),
            Self::Mon => Ok(Some(Cow::Borrowed("mon"))),
            Self::Mos => Ok(Some(Cow::Borrowed("mos"))),
            Self::Mri => Ok(Some(Cow::Borrowed("mri"))),
            Self::Msa => Ok(Some(Cow::Borrowed("msa"))),
            Self::Mul => Ok(Some(Cow::Borrowed("mul"))),
            Self::Mun => Ok(Some(Cow::Borrowed("mun"))),
            Self::Mus => Ok(Some(Cow::Borrowed("mus"))),
            Self::Mwr => Ok(Some(Cow::Borrowed("mwr"))),
            Self::Mya => Ok(Some(Cow::Borrowed("mya"))),
            Self::Myn => Ok(Some(Cow::Borrowed("myn"))),
            Self::Nah => Ok(Some(Cow::Borrowed("nah"))),
            Self::Nai => Ok(Some(Cow::Borrowed("nai"))),
            Self::Nau => Ok(Some(Cow::Borrowed("nau"))),
            Self::Nav => Ok(Some(Cow::Borrowed("nav"))),
            Self::Nbl => Ok(Some(Cow::Borrowed("nbl"))),
            Self::Nde => Ok(Some(Cow::Borrowed("nde"))),
            Self::Ndo => Ok(Some(Cow::Borrowed("ndo"))),
            Self::Nds => Ok(Some(Cow::Borrowed("nds"))),
            Self::Nep => Ok(Some(Cow::Borrowed("nep"))),
            Self::New => Ok(Some(Cow::Borrowed("new"))),
            Self::Nia => Ok(Some(Cow::Borrowed("nia"))),
            Self::Nic => Ok(Some(Cow::Borrowed("nic"))),
            Self::Niu => Ok(Some(Cow::Borrowed("niu"))),
            Self::Nld => Ok(Some(Cow::Borrowed("nld"))),
            Self::Nno => Ok(Some(Cow::Borrowed("nno"))),
            Self::Nob => Ok(Some(Cow::Borrowed("nob"))),
            Self::Non => Ok(Some(Cow::Borrowed("non"))),
            Self::Nor => Ok(Some(Cow::Borrowed("nor"))),
            Self::Nso => Ok(Some(Cow::Borrowed("nso"))),
            Self::Nub => Ok(Some(Cow::Borrowed("nub"))),
            Self::Nya => Ok(Some(Cow::Borrowed("nya"))),
            Self::Nym => Ok(Some(Cow::Borrowed("nym"))),
            Self::Nyn => Ok(Some(Cow::Borrowed("nyn"))),
            Self::Nyo => Ok(Some(Cow::Borrowed("nyo"))),
            Self::Nzi => Ok(Some(Cow::Borrowed("nzi"))),
            Self::Oci => Ok(Some(Cow::Borrowed("oci"))),
            Self::Oji => Ok(Some(Cow::Borrowed("oji"))),
            Self::Ori => Ok(Some(Cow::Borrowed("ori"))),
            Self::Orm => Ok(Some(Cow::Borrowed("orm"))),
            Self::Osa => Ok(Some(Cow::Borrowed("osa"))),
            Self::Oss => Ok(Some(Cow::Borrowed("oss"))),
            Self::Ota => Ok(Some(Cow::Borrowed("ota"))),
            Self::Oto => Ok(Some(Cow::Borrowed("oto"))),
            Self::Paa => Ok(Some(Cow::Borrowed("paa"))),
            Self::Pag => Ok(Some(Cow::Borrowed("pag"))),
            Self::Pal => Ok(Some(Cow::Borrowed("pal"))),
            Self::Pam => Ok(Some(Cow::Borrowed("pam"))),
            Self::Pan => Ok(Some(Cow::Borrowed("pan"))),
            Self::Pap => Ok(Some(Cow::Borrowed("pap"))),
            Self::Pau => Ok(Some(Cow::Borrowed("pau"))),
            Self::Peo => Ok(Some(Cow::Borrowed("peo"))),
            Self::Per => Ok(Some(Cow::Borrowed("per"))),
            Self::Phi => Ok(Some(Cow::Borrowed("phi"))),
            Self::Phn => Ok(Some(Cow::Borrowed("phn"))),
            Self::Pli => Ok(Some(Cow::Borrowed("pli"))),
            Self::Pol => Ok(Some(Cow::Borrowed("pol"))),
            Self::Pon => Ok(Some(Cow::Borrowed("pon"))),
            Self::Por => Ok(Some(Cow::Borrowed("por"))),
            Self::Pra => Ok(Some(Cow::Borrowed("pra"))),
            Self::Pro => Ok(Some(Cow::Borrowed("pro"))),
            Self::Pus => Ok(Some(Cow::Borrowed("pus"))),
            Self::Qaa => Ok(Some(Cow::Borrowed("qaa"))),
            Self::Que => Ok(Some(Cow::Borrowed("que"))),
            Self::Raj => Ok(Some(Cow::Borrowed("raj"))),
            Self::Rap => Ok(Some(Cow::Borrowed("rap"))),
            Self::Rar => Ok(Some(Cow::Borrowed("rar"))),
            Self::Roa => Ok(Some(Cow::Borrowed("roa"))),
            Self::Roh => Ok(Some(Cow::Borrowed("roh"))),
            Self::Rom => Ok(Some(Cow::Borrowed("rom"))),
            Self::Ron => Ok(Some(Cow::Borrowed("ron"))),
            Self::Rum => Ok(Some(Cow::Borrowed("rum"))),
            Self::Run => Ok(Some(Cow::Borrowed("run"))),
            Self::Rus => Ok(Some(Cow::Borrowed("rus"))),
            Self::Sad => Ok(Some(Cow::Borrowed("sad"))),
            Self::Sag => Ok(Some(Cow::Borrowed("sag"))),
            Self::Sah => Ok(Some(Cow::Borrowed("sah"))),
            Self::Sai => Ok(Some(Cow::Borrowed("sai"))),
            Self::Sal => Ok(Some(Cow::Borrowed("sal"))),
            Self::Sam => Ok(Some(Cow::Borrowed("sam"))),
            Self::San => Ok(Some(Cow::Borrowed("san"))),
            Self::Sas => Ok(Some(Cow::Borrowed("sas"))),
            Self::Sat => Ok(Some(Cow::Borrowed("sat"))),
            Self::Scc => Ok(Some(Cow::Borrowed("scc"))),
            Self::Sco => Ok(Some(Cow::Borrowed("sco"))),
            Self::Scr => Ok(Some(Cow::Borrowed("scr"))),
            Self::Sel => Ok(Some(Cow::Borrowed("sel"))),
            Self::Sem => Ok(Some(Cow::Borrowed("sem"))),
            Self::Sga => Ok(Some(Cow::Borrowed("sga"))),
            Self::Sgn => Ok(Some(Cow::Borrowed("sgn"))),
            Self::Shn => Ok(Some(Cow::Borrowed("shn"))),
            Self::Sid => Ok(Some(Cow::Borrowed("sid"))),
            Self::Sin => Ok(Some(Cow::Borrowed("sin"))),
            Self::Sio => Ok(Some(Cow::Borrowed("sio"))),
            Self::Sit => Ok(Some(Cow::Borrowed("sit"))),
            Self::Sla => Ok(Some(Cow::Borrowed("sla"))),
            Self::Slk => Ok(Some(Cow::Borrowed("slk"))),
            Self::Slo => Ok(Some(Cow::Borrowed("slo"))),
            Self::Slv => Ok(Some(Cow::Borrowed("slv"))),
            Self::Sme => Ok(Some(Cow::Borrowed("sme"))),
            Self::Smi => Ok(Some(Cow::Borrowed("smi"))),
            Self::Smo => Ok(Some(Cow::Borrowed("smo"))),
            Self::Sna => Ok(Some(Cow::Borrowed("sna"))),
            Self::Snd => Ok(Some(Cow::Borrowed("snd"))),
            Self::Snk => Ok(Some(Cow::Borrowed("snk"))),
            Self::Sog => Ok(Some(Cow::Borrowed("sog"))),
            Self::Som => Ok(Some(Cow::Borrowed("som"))),
            Self::Son => Ok(Some(Cow::Borrowed("son"))),
            Self::Sot => Ok(Some(Cow::Borrowed("sot"))),
            Self::Spa => Ok(Some(Cow::Borrowed("spa"))),
            Self::Sqi => Ok(Some(Cow::Borrowed("sqi"))),
            Self::Srd => Ok(Some(Cow::Borrowed("srd"))),
            Self::Srp => Ok(Some(Cow::Borrowed("srp"))),
            Self::Srr => Ok(Some(Cow::Borrowed("srr"))),
            Self::Ssa => Ok(Some(Cow::Borrowed("ssa"))),
            Self::Ssw => Ok(Some(Cow::Borrowed("ssw"))),
            Self::Suk => Ok(Some(Cow::Borrowed("suk"))),
            Self::Sun => Ok(Some(Cow::Borrowed("sun"))),
            Self::Sus => Ok(Some(Cow::Borrowed("sus"))),
            Self::Sux => Ok(Some(Cow::Borrowed("sux"))),
            Self::Swa => Ok(Some(Cow::Borrowed("swa"))),
            Self::Swe => Ok(Some(Cow::Borrowed("swe"))),
            Self::Syr => Ok(Some(Cow::Borrowed("syr"))),
            Self::Tah => Ok(Some(Cow::Borrowed("tah"))),
            Self::Tai => Ok(Some(Cow::Borrowed("tai"))),
            Self::Tam => Ok(Some(Cow::Borrowed("tam"))),
            Self::Tat => Ok(Some(Cow::Borrowed("tat"))),
            Self::Tel => Ok(Some(Cow::Borrowed("tel"))),
            Self::Tem => Ok(Some(Cow::Borrowed("tem"))),
            Self::Ter => Ok(Some(Cow::Borrowed("ter"))),
            Self::Tet => Ok(Some(Cow::Borrowed("tet"))),
            Self::Tgk => Ok(Some(Cow::Borrowed("tgk"))),
            Self::Tgl => Ok(Some(Cow::Borrowed("tgl"))),
            Self::Tha => Ok(Some(Cow::Borrowed("tha"))),
            Self::Tib => Ok(Some(Cow::Borrowed("tib"))),
            Self::Tig => Ok(Some(Cow::Borrowed("tig"))),
            Self::Tir => Ok(Some(Cow::Borrowed("tir"))),
            Self::Tiv => Ok(Some(Cow::Borrowed("tiv"))),
            Self::Tkl => Ok(Some(Cow::Borrowed("tkl"))),
            Self::Tli => Ok(Some(Cow::Borrowed("tli"))),
            Self::Tmh => Ok(Some(Cow::Borrowed("tmh"))),
            Self::Tog => Ok(Some(Cow::Borrowed("tog"))),
            Self::Ton => Ok(Some(Cow::Borrowed("ton"))),
            Self::Tpi => Ok(Some(Cow::Borrowed("tpi"))),
            Self::Tsi => Ok(Some(Cow::Borrowed("tsi"))),
            Self::Tsn => Ok(Some(Cow::Borrowed("tsn"))),
            Self::Tso => Ok(Some(Cow::Borrowed("tso"))),
            Self::Tuk => Ok(Some(Cow::Borrowed("tuk"))),
            Self::Tum => Ok(Some(Cow::Borrowed("tum"))),
            Self::Tur => Ok(Some(Cow::Borrowed("tur"))),
            Self::Tut => Ok(Some(Cow::Borrowed("tut"))),
            Self::Tvl => Ok(Some(Cow::Borrowed("tvl"))),
            Self::Twi => Ok(Some(Cow::Borrowed("twi"))),
            Self::Tyv => Ok(Some(Cow::Borrowed("tyv"))),
            Self::Uga => Ok(Some(Cow::Borrowed("uga"))),
            Self::Uig => Ok(Some(Cow::Borrowed("uig"))),
            Self::Ukr => Ok(Some(Cow::Borrowed("ukr"))),
            Self::Umb => Ok(Some(Cow::Borrowed("umb"))),
            Self::Und => Ok(Some(Cow::Borrowed("und"))),
            Self::Urd => Ok(Some(Cow::Borrowed("urd"))),
            Self::Uzb => Ok(Some(Cow::Borrowed("uzb"))),
            Self::Vai => Ok(Some(Cow::Borrowed("vai"))),
            Self::Ven => Ok(Some(Cow::Borrowed("ven"))),
            Self::Vie => Ok(Some(Cow::Borrowed("vie"))),
            Self::Vol => Ok(Some(Cow::Borrowed("vol"))),
            Self::Vot => Ok(Some(Cow::Borrowed("vot"))),
            Self::Wak => Ok(Some(Cow::Borrowed("wak"))),
            Self::Wal => Ok(Some(Cow::Borrowed("wal"))),
            Self::War => Ok(Some(Cow::Borrowed("war"))),
            Self::Was => Ok(Some(Cow::Borrowed("was"))),
            Self::Wel => Ok(Some(Cow::Borrowed("wel"))),
            Self::Wen => Ok(Some(Cow::Borrowed("wen"))),
            Self::Wol => Ok(Some(Cow::Borrowed("wol"))),
            Self::Xho => Ok(Some(Cow::Borrowed("xho"))),
            Self::Yao => Ok(Some(Cow::Borrowed("yao"))),
            Self::Yap => Ok(Some(Cow::Borrowed("yap"))),
            Self::Yid => Ok(Some(Cow::Borrowed("yid"))),
            Self::Yor => Ok(Some(Cow::Borrowed("yor"))),
            Self::Ypk => Ok(Some(Cow::Borrowed("ypk"))),
            Self::Zap => Ok(Some(Cow::Borrowed("zap"))),
            Self::Zen => Ok(Some(Cow::Borrowed("zen"))),
            Self::Zha => Ok(Some(Cow::Borrowed("zha"))),
            Self::Zho => Ok(Some(Cow::Borrowed("zho"))),
            Self::Znd => Ok(Some(Cow::Borrowed("znd"))),
            Self::Zul => Ok(Some(Cow::Borrowed("zul"))),
        }
    }
}
impl WithSerializeToBytes for DtLang {}
impl DeserializeBytes for DtLang {
    fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
        match bytes {
            b"aar" => Ok(Self::Aar),
            b"abk" => Ok(Self::Abk),
            b"ace" => Ok(Self::Ace),
            b"ach" => Ok(Self::Ach),
            b"ada" => Ok(Self::Ada),
            b"afa" => Ok(Self::Afa),
            b"afh" => Ok(Self::Afh),
            b"afr" => Ok(Self::Afr),
            b"aka" => Ok(Self::Aka),
            b"akk" => Ok(Self::Akk),
            b"alb" => Ok(Self::Alb),
            b"ale" => Ok(Self::Ale),
            b"alg" => Ok(Self::Alg),
            b"amh" => Ok(Self::Amh),
            b"ang" => Ok(Self::Ang),
            b"apa" => Ok(Self::Apa),
            b"ara" => Ok(Self::Ara),
            b"arc" => Ok(Self::Arc),
            b"arm" => Ok(Self::Arm),
            b"arn" => Ok(Self::Arn),
            b"arp" => Ok(Self::Arp),
            b"art" => Ok(Self::Art),
            b"arw" => Ok(Self::Arw),
            b"asm" => Ok(Self::Asm),
            b"ath" => Ok(Self::Ath),
            b"aus" => Ok(Self::Aus),
            b"ava" => Ok(Self::Ava),
            b"ave" => Ok(Self::Ave),
            b"awa" => Ok(Self::Awa),
            b"aym" => Ok(Self::Aym),
            b"aze" => Ok(Self::Aze),
            b"bad" => Ok(Self::Bad),
            b"bai" => Ok(Self::Bai),
            b"bak" => Ok(Self::Bak),
            b"bal" => Ok(Self::Bal),
            b"bam" => Ok(Self::Bam),
            b"ban" => Ok(Self::Ban),
            b"baq" => Ok(Self::Baq),
            b"bas" => Ok(Self::Bas),
            b"bat" => Ok(Self::Bat),
            b"bej" => Ok(Self::Bej),
            b"bel" => Ok(Self::Bel),
            b"bem" => Ok(Self::Bem),
            b"ben" => Ok(Self::Ben),
            b"ber" => Ok(Self::Ber),
            b"bho" => Ok(Self::Bho),
            b"bih" => Ok(Self::Bih),
            b"bik" => Ok(Self::Bik),
            b"bin" => Ok(Self::Bin),
            b"bis" => Ok(Self::Bis),
            b"bla" => Ok(Self::Bla),
            b"bnt" => Ok(Self::Bnt),
            b"bod" => Ok(Self::Bod),
            b"bos" => Ok(Self::Bos),
            b"bra" => Ok(Self::Bra),
            b"bre" => Ok(Self::Bre),
            b"btk" => Ok(Self::Btk),
            b"bua" => Ok(Self::Bua),
            b"bug" => Ok(Self::Bug),
            b"bul" => Ok(Self::Bul),
            b"bur" => Ok(Self::Bur),
            b"cad" => Ok(Self::Cad),
            b"cai" => Ok(Self::Cai),
            b"car" => Ok(Self::Car),
            b"cat" => Ok(Self::Cat),
            b"cau" => Ok(Self::Cau),
            b"ceb" => Ok(Self::Ceb),
            b"cel" => Ok(Self::Cel),
            b"ces" => Ok(Self::Ces),
            b"cha" => Ok(Self::Cha),
            b"chb" => Ok(Self::Chb),
            b"che" => Ok(Self::Che),
            b"chg" => Ok(Self::Chg),
            b"chi" => Ok(Self::Chi),
            b"chk" => Ok(Self::Chk),
            b"chm" => Ok(Self::Chm),
            b"chn" => Ok(Self::Chn),
            b"cho" => Ok(Self::Cho),
            b"chp" => Ok(Self::Chp),
            b"chr" => Ok(Self::Chr),
            b"chu" => Ok(Self::Chu),
            b"chv" => Ok(Self::Chv),
            b"chy" => Ok(Self::Chy),
            b"cmc" => Ok(Self::Cmc),
            b"cop" => Ok(Self::Cop),
            b"cor" => Ok(Self::Cor),
            b"cos" => Ok(Self::Cos),
            b"cpe" => Ok(Self::Cpe),
            b"cpf" => Ok(Self::Cpf),
            b"cpp" => Ok(Self::Cpp),
            b"cre" => Ok(Self::Cre),
            b"crp" => Ok(Self::Crp),
            b"cus" => Ok(Self::Cus),
            b"cym" => Ok(Self::Cym),
            b"cze" => Ok(Self::Cze),
            b"dak" => Ok(Self::Dak),
            b"dan" => Ok(Self::Dan),
            b"day" => Ok(Self::Day),
            b"del" => Ok(Self::Del),
            b"den" => Ok(Self::Den),
            b"deu" => Ok(Self::Deu),
            b"dgr" => Ok(Self::Dgr),
            b"din" => Ok(Self::Din),
            b"div" => Ok(Self::Div),
            b"doi" => Ok(Self::Doi),
            b"dra" => Ok(Self::Dra),
            b"dua" => Ok(Self::Dua),
            b"dum" => Ok(Self::Dum),
            b"dut" => Ok(Self::Dut),
            b"dyu" => Ok(Self::Dyu),
            b"dzo" => Ok(Self::Dzo),
            b"efi" => Ok(Self::Efi),
            b"egy" => Ok(Self::Egy),
            b"eka" => Ok(Self::Eka),
            b"ell" => Ok(Self::Ell),
            b"elx" => Ok(Self::Elx),
            b"eng" => Ok(Self::Eng),
            b"enm" => Ok(Self::Enm),
            b"epo" => Ok(Self::Epo),
            b"est" => Ok(Self::Est),
            b"eus" => Ok(Self::Eus),
            b"ewe" => Ok(Self::Ewe),
            b"ewo" => Ok(Self::Ewo),
            b"fan" => Ok(Self::Fan),
            b"fao" => Ok(Self::Fao),
            b"fas" => Ok(Self::Fas),
            b"fat" => Ok(Self::Fat),
            b"fij" => Ok(Self::Fij),
            b"fin" => Ok(Self::Fin),
            b"fiu" => Ok(Self::Fiu),
            b"fon" => Ok(Self::Fon),
            b"fra" => Ok(Self::Fra),
            b"fre" => Ok(Self::Fre),
            b"frm" => Ok(Self::Frm),
            b"fro" => Ok(Self::Fro),
            b"fry" => Ok(Self::Fry),
            b"ful" => Ok(Self::Ful),
            b"fur" => Ok(Self::Fur),
            b"gaa" => Ok(Self::Gaa),
            b"gay" => Ok(Self::Gay),
            b"gba" => Ok(Self::Gba),
            b"gem" => Ok(Self::Gem),
            b"geo" => Ok(Self::Geo),
            b"ger" => Ok(Self::Ger),
            b"gez" => Ok(Self::Gez),
            b"gil" => Ok(Self::Gil),
            b"gla" => Ok(Self::Gla),
            b"gle" => Ok(Self::Gle),
            b"glg" => Ok(Self::Glg),
            b"glv" => Ok(Self::Glv),
            b"gmh" => Ok(Self::Gmh),
            b"goh" => Ok(Self::Goh),
            b"gon" => Ok(Self::Gon),
            b"gor" => Ok(Self::Gor),
            b"got" => Ok(Self::Got),
            b"grb" => Ok(Self::Grb),
            b"grc" => Ok(Self::Grc),
            b"gre" => Ok(Self::Gre),
            b"grn" => Ok(Self::Grn),
            b"guj" => Ok(Self::Guj),
            b"gwi" => Ok(Self::Gwi),
            b"hai" => Ok(Self::Hai),
            b"hau" => Ok(Self::Hau),
            b"haw" => Ok(Self::Haw),
            b"heb" => Ok(Self::Heb),
            b"her" => Ok(Self::Her),
            b"hil" => Ok(Self::Hil),
            b"him" => Ok(Self::Him),
            b"hin" => Ok(Self::Hin),
            b"hit" => Ok(Self::Hit),
            b"hmn" => Ok(Self::Hmn),
            b"hmo" => Ok(Self::Hmo),
            b"hrv" => Ok(Self::Hrv),
            b"hun" => Ok(Self::Hun),
            b"hup" => Ok(Self::Hup),
            b"hye" => Ok(Self::Hye),
            b"iba" => Ok(Self::Iba),
            b"ibo" => Ok(Self::Ibo),
            b"ice" => Ok(Self::Ice),
            b"ijo" => Ok(Self::Ijo),
            b"iku" => Ok(Self::Iku),
            b"ile" => Ok(Self::Ile),
            b"ilo" => Ok(Self::Ilo),
            b"ina" => Ok(Self::Ina),
            b"inc" => Ok(Self::Inc),
            b"ind" => Ok(Self::Ind),
            b"ine" => Ok(Self::Ine),
            b"ipk" => Ok(Self::Ipk),
            b"ira" => Ok(Self::Ira),
            b"iro" => Ok(Self::Iro),
            b"isl" => Ok(Self::Isl),
            b"ita" => Ok(Self::Ita),
            b"jav" => Ok(Self::Jav),
            b"jpn" => Ok(Self::Jpn),
            b"jpr" => Ok(Self::Jpr),
            b"jrb" => Ok(Self::Jrb),
            b"kaa" => Ok(Self::Kaa),
            b"kab" => Ok(Self::Kab),
            b"kac" => Ok(Self::Kac),
            b"kal" => Ok(Self::Kal),
            b"kam" => Ok(Self::Kam),
            b"kan" => Ok(Self::Kan),
            b"kar" => Ok(Self::Kar),
            b"kas" => Ok(Self::Kas),
            b"kat" => Ok(Self::Kat),
            b"kau" => Ok(Self::Kau),
            b"kaw" => Ok(Self::Kaw),
            b"kaz" => Ok(Self::Kaz),
            b"kha" => Ok(Self::Kha),
            b"khi" => Ok(Self::Khi),
            b"khm" => Ok(Self::Khm),
            b"kho" => Ok(Self::Kho),
            b"kik" => Ok(Self::Kik),
            b"kin" => Ok(Self::Kin),
            b"kir" => Ok(Self::Kir),
            b"kmb" => Ok(Self::Kmb),
            b"kok" => Ok(Self::Kok),
            b"kom" => Ok(Self::Kom),
            b"kon" => Ok(Self::Kon),
            b"kor" => Ok(Self::Kor),
            b"kos" => Ok(Self::Kos),
            b"kpe" => Ok(Self::Kpe),
            b"kro" => Ok(Self::Kro),
            b"kru" => Ok(Self::Kru),
            b"kua" => Ok(Self::Kua),
            b"kum" => Ok(Self::Kum),
            b"kur" => Ok(Self::Kur),
            b"kut" => Ok(Self::Kut),
            b"lad" => Ok(Self::Lad),
            b"lah" => Ok(Self::Lah),
            b"lam" => Ok(Self::Lam),
            b"lao" => Ok(Self::Lao),
            b"lat" => Ok(Self::Lat),
            b"lav" => Ok(Self::Lav),
            b"lez" => Ok(Self::Lez),
            b"lin" => Ok(Self::Lin),
            b"lit" => Ok(Self::Lit),
            b"lol" => Ok(Self::Lol),
            b"loz" => Ok(Self::Loz),
            b"ltz" => Ok(Self::Ltz),
            b"lua" => Ok(Self::Lua),
            b"lub" => Ok(Self::Lub),
            b"lug" => Ok(Self::Lug),
            b"lui" => Ok(Self::Lui),
            b"lun" => Ok(Self::Lun),
            b"luo" => Ok(Self::Luo),
            b"lus" => Ok(Self::Lus),
            b"mac" => Ok(Self::Mac),
            b"mad" => Ok(Self::Mad),
            b"mag" => Ok(Self::Mag),
            b"mah" => Ok(Self::Mah),
            b"mai" => Ok(Self::Mai),
            b"mak" => Ok(Self::Mak),
            b"mal" => Ok(Self::Mal),
            b"man" => Ok(Self::Man),
            b"mao" => Ok(Self::Mao),
            b"map" => Ok(Self::Map),
            b"mar" => Ok(Self::Mar),
            b"mas" => Ok(Self::Mas),
            b"may" => Ok(Self::May),
            b"mdr" => Ok(Self::Mdr),
            b"men" => Ok(Self::Men),
            b"mga" => Ok(Self::Mga),
            b"mic" => Ok(Self::Mic),
            b"min" => Ok(Self::Min),
            b"mis" => Ok(Self::Mis),
            b"mkd" => Ok(Self::Mkd),
            b"mkh" => Ok(Self::Mkh),
            b"mlg" => Ok(Self::Mlg),
            b"mlt" => Ok(Self::Mlt),
            b"mnc" => Ok(Self::Mnc),
            b"mni" => Ok(Self::Mni),
            b"mno" => Ok(Self::Mno),
            b"moh" => Ok(Self::Moh),
            b"mol" => Ok(Self::Mol),
            b"mon" => Ok(Self::Mon),
            b"mos" => Ok(Self::Mos),
            b"mri" => Ok(Self::Mri),
            b"msa" => Ok(Self::Msa),
            b"mul" => Ok(Self::Mul),
            b"mun" => Ok(Self::Mun),
            b"mus" => Ok(Self::Mus),
            b"mwr" => Ok(Self::Mwr),
            b"mya" => Ok(Self::Mya),
            b"myn" => Ok(Self::Myn),
            b"nah" => Ok(Self::Nah),
            b"nai" => Ok(Self::Nai),
            b"nau" => Ok(Self::Nau),
            b"nav" => Ok(Self::Nav),
            b"nbl" => Ok(Self::Nbl),
            b"nde" => Ok(Self::Nde),
            b"ndo" => Ok(Self::Ndo),
            b"nds" => Ok(Self::Nds),
            b"nep" => Ok(Self::Nep),
            b"new" => Ok(Self::New),
            b"nia" => Ok(Self::Nia),
            b"nic" => Ok(Self::Nic),
            b"niu" => Ok(Self::Niu),
            b"nld" => Ok(Self::Nld),
            b"nno" => Ok(Self::Nno),
            b"nob" => Ok(Self::Nob),
            b"non" => Ok(Self::Non),
            b"nor" => Ok(Self::Nor),
            b"nso" => Ok(Self::Nso),
            b"nub" => Ok(Self::Nub),
            b"nya" => Ok(Self::Nya),
            b"nym" => Ok(Self::Nym),
            b"nyn" => Ok(Self::Nyn),
            b"nyo" => Ok(Self::Nyo),
            b"nzi" => Ok(Self::Nzi),
            b"oci" => Ok(Self::Oci),
            b"oji" => Ok(Self::Oji),
            b"ori" => Ok(Self::Ori),
            b"orm" => Ok(Self::Orm),
            b"osa" => Ok(Self::Osa),
            b"oss" => Ok(Self::Oss),
            b"ota" => Ok(Self::Ota),
            b"oto" => Ok(Self::Oto),
            b"paa" => Ok(Self::Paa),
            b"pag" => Ok(Self::Pag),
            b"pal" => Ok(Self::Pal),
            b"pam" => Ok(Self::Pam),
            b"pan" => Ok(Self::Pan),
            b"pap" => Ok(Self::Pap),
            b"pau" => Ok(Self::Pau),
            b"peo" => Ok(Self::Peo),
            b"per" => Ok(Self::Per),
            b"phi" => Ok(Self::Phi),
            b"phn" => Ok(Self::Phn),
            b"pli" => Ok(Self::Pli),
            b"pol" => Ok(Self::Pol),
            b"pon" => Ok(Self::Pon),
            b"por" => Ok(Self::Por),
            b"pra" => Ok(Self::Pra),
            b"pro" => Ok(Self::Pro),
            b"pus" => Ok(Self::Pus),
            b"qaa" => Ok(Self::Qaa),
            b"que" => Ok(Self::Que),
            b"raj" => Ok(Self::Raj),
            b"rap" => Ok(Self::Rap),
            b"rar" => Ok(Self::Rar),
            b"roa" => Ok(Self::Roa),
            b"roh" => Ok(Self::Roh),
            b"rom" => Ok(Self::Rom),
            b"ron" => Ok(Self::Ron),
            b"rum" => Ok(Self::Rum),
            b"run" => Ok(Self::Run),
            b"rus" => Ok(Self::Rus),
            b"sad" => Ok(Self::Sad),
            b"sag" => Ok(Self::Sag),
            b"sah" => Ok(Self::Sah),
            b"sai" => Ok(Self::Sai),
            b"sal" => Ok(Self::Sal),
            b"sam" => Ok(Self::Sam),
            b"san" => Ok(Self::San),
            b"sas" => Ok(Self::Sas),
            b"sat" => Ok(Self::Sat),
            b"scc" => Ok(Self::Scc),
            b"sco" => Ok(Self::Sco),
            b"scr" => Ok(Self::Scr),
            b"sel" => Ok(Self::Sel),
            b"sem" => Ok(Self::Sem),
            b"sga" => Ok(Self::Sga),
            b"sgn" => Ok(Self::Sgn),
            b"shn" => Ok(Self::Shn),
            b"sid" => Ok(Self::Sid),
            b"sin" => Ok(Self::Sin),
            b"sio" => Ok(Self::Sio),
            b"sit" => Ok(Self::Sit),
            b"sla" => Ok(Self::Sla),
            b"slk" => Ok(Self::Slk),
            b"slo" => Ok(Self::Slo),
            b"slv" => Ok(Self::Slv),
            b"sme" => Ok(Self::Sme),
            b"smi" => Ok(Self::Smi),
            b"smo" => Ok(Self::Smo),
            b"sna" => Ok(Self::Sna),
            b"snd" => Ok(Self::Snd),
            b"snk" => Ok(Self::Snk),
            b"sog" => Ok(Self::Sog),
            b"som" => Ok(Self::Som),
            b"son" => Ok(Self::Son),
            b"sot" => Ok(Self::Sot),
            b"spa" => Ok(Self::Spa),
            b"sqi" => Ok(Self::Sqi),
            b"srd" => Ok(Self::Srd),
            b"srp" => Ok(Self::Srp),
            b"srr" => Ok(Self::Srr),
            b"ssa" => Ok(Self::Ssa),
            b"ssw" => Ok(Self::Ssw),
            b"suk" => Ok(Self::Suk),
            b"sun" => Ok(Self::Sun),
            b"sus" => Ok(Self::Sus),
            b"sux" => Ok(Self::Sux),
            b"swa" => Ok(Self::Swa),
            b"swe" => Ok(Self::Swe),
            b"syr" => Ok(Self::Syr),
            b"tah" => Ok(Self::Tah),
            b"tai" => Ok(Self::Tai),
            b"tam" => Ok(Self::Tam),
            b"tat" => Ok(Self::Tat),
            b"tel" => Ok(Self::Tel),
            b"tem" => Ok(Self::Tem),
            b"ter" => Ok(Self::Ter),
            b"tet" => Ok(Self::Tet),
            b"tgk" => Ok(Self::Tgk),
            b"tgl" => Ok(Self::Tgl),
            b"tha" => Ok(Self::Tha),
            b"tib" => Ok(Self::Tib),
            b"tig" => Ok(Self::Tig),
            b"tir" => Ok(Self::Tir),
            b"tiv" => Ok(Self::Tiv),
            b"tkl" => Ok(Self::Tkl),
            b"tli" => Ok(Self::Tli),
            b"tmh" => Ok(Self::Tmh),
            b"tog" => Ok(Self::Tog),
            b"ton" => Ok(Self::Ton),
            b"tpi" => Ok(Self::Tpi),
            b"tsi" => Ok(Self::Tsi),
            b"tsn" => Ok(Self::Tsn),
            b"tso" => Ok(Self::Tso),
            b"tuk" => Ok(Self::Tuk),
            b"tum" => Ok(Self::Tum),
            b"tur" => Ok(Self::Tur),
            b"tut" => Ok(Self::Tut),
            b"tvl" => Ok(Self::Tvl),
            b"twi" => Ok(Self::Twi),
            b"tyv" => Ok(Self::Tyv),
            b"uga" => Ok(Self::Uga),
            b"uig" => Ok(Self::Uig),
            b"ukr" => Ok(Self::Ukr),
            b"umb" => Ok(Self::Umb),
            b"und" => Ok(Self::Und),
            b"urd" => Ok(Self::Urd),
            b"uzb" => Ok(Self::Uzb),
            b"vai" => Ok(Self::Vai),
            b"ven" => Ok(Self::Ven),
            b"vie" => Ok(Self::Vie),
            b"vol" => Ok(Self::Vol),
            b"vot" => Ok(Self::Vot),
            b"wak" => Ok(Self::Wak),
            b"wal" => Ok(Self::Wal),
            b"war" => Ok(Self::War),
            b"was" => Ok(Self::Was),
            b"wel" => Ok(Self::Wel),
            b"wen" => Ok(Self::Wen),
            b"wol" => Ok(Self::Wol),
            b"xho" => Ok(Self::Xho),
            b"yao" => Ok(Self::Yao),
            b"yap" => Ok(Self::Yap),
            b"yid" => Ok(Self::Yid),
            b"yor" => Ok(Self::Yor),
            b"ypk" => Ok(Self::Ypk),
            b"zap" => Ok(Self::Zap),
            b"zen" => Ok(Self::Zen),
            b"zha" => Ok(Self::Zha),
            b"zho" => Ok(Self::Zho),
            b"znd" => Ok(Self::Znd),
            b"zul" => Ok(Self::Zul),
            x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
                RawByteStr::from_slice(x),
            ))),
        }
    }
}
impl WithDeserializerFromBytes for DtLang {}
#[derive(Debug)]
pub enum CatalogDatetimeType {
    GenerationDate,
}
impl SerializeBytes for CatalogDatetimeType {
    fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
        match self {
            Self::GenerationDate => Ok(Some(Cow::Borrowed("generation_date"))),
        }
    }
}
impl WithSerializeToBytes for CatalogDatetimeType {}
impl DeserializeBytes for CatalogDatetimeType {
    fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
        match bytes {
            b"generation_date" => Ok(Self::GenerationDate),
            x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
                RawByteStr::from_slice(x),
            ))),
        }
    }
}
impl WithDeserializerFromBytes for CatalogDatetimeType {}
#[derive(Debug)]
pub enum SupplierAddressType {
    Supplier,
}
impl SerializeBytes for SupplierAddressType {
    fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
        match self {
            Self::Supplier => Ok(Some(Cow::Borrowed("supplier"))),
        }
    }
}
impl WithSerializeToBytes for SupplierAddressType {}
impl DeserializeBytes for SupplierAddressType {
    fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
        match bytes {
            b"supplier" => Ok(Self::Supplier),
            x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
                RawByteStr::from_slice(x),
            ))),
        }
    }
}
impl WithDeserializerFromBytes for SupplierAddressType {}
#[derive(Debug)]
pub struct MimeElementType {
    pub mime_type: String,
    pub mime_source: Vec<DtMlstring>,
    pub mime_descr: Vec<DtMlstring>,
    pub mime_alt: Vec<DtMlstring>,
    pub mime_purpose: MimePurposeElementType,
}
impl WithSerializer for MimeElementType {
    type Serializer<'x> = quick_xml_serialize::MimeElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::MimeElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::MimeElementTypeSerializerState::Init__),
            name: name.unwrap_or("MIME"),
            is_root,
        })
    }
}
impl WithDeserializer for MimeElementType {
    type Deserializer = quick_xml_deserialize::MimeElementTypeDeserializer;
}
#[derive(Debug)]
pub struct InternationalPidElementType {
    pub type_: Option<String>,
    pub content: String,
}
impl WithSerializer for InternationalPidElementType {
    type Serializer<'x> = quick_xml_serialize::InternationalPidElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::InternationalPidElementTypeSerializer {
            value: self,
            state: Box::new(
                quick_xml_serialize::InternationalPidElementTypeSerializerState::Init__,
            ),
            name: name.unwrap_or("INTERNATIONAL_PID"),
            is_root,
        })
    }
}
impl WithDeserializer for InternationalPidElementType {
    type Deserializer = quick_xml_deserialize::InternationalPidElementTypeDeserializer;
}
#[derive(Debug)]
pub struct BuyerPidElementType {
    pub type_: Option<String>,
    pub content: String,
}
impl WithSerializer for BuyerPidElementType {
    type Serializer<'x> = quick_xml_serialize::BuyerPidElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::BuyerPidElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::BuyerPidElementTypeSerializerState::Init__),
            name: name.unwrap_or("BUYER_PID"),
            is_root,
        })
    }
}
impl WithDeserializer for BuyerPidElementType {
    type Deserializer = quick_xml_deserialize::BuyerPidElementTypeDeserializer;
}
#[derive(Debug)]
pub struct SpecialTreatmentClassElementType {
    pub type_: String,
    pub content: String,
}
impl WithSerializer for SpecialTreatmentClassElementType {
    type Serializer<'x> = quick_xml_serialize::SpecialTreatmentClassElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(
            quick_xml_serialize::SpecialTreatmentClassElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::SpecialTreatmentClassElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("SPECIAL_TREATMENT_CLASS"),
                is_root,
            },
        )
    }
}
impl WithDeserializer for SpecialTreatmentClassElementType {
    type Deserializer = quick_xml_deserialize::SpecialTreatmentClassElementTypeDeserializer;
}
#[derive(Debug)]
pub struct RemarksElementType {
    pub lang: Option<DtLang>,
    pub type_: Option<String>,
    pub content: String,
}
impl WithSerializer for RemarksElementType {
    type Serializer<'x> = quick_xml_serialize::RemarksElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::RemarksElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::RemarksElementTypeSerializerState::Init__),
            name: name.unwrap_or("REMARKS"),
            is_root,
        })
    }
}
impl WithDeserializer for RemarksElementType {
    type Deserializer = quick_xml_deserialize::RemarksElementTypeDeserializer;
}
#[derive(Debug)]
pub struct ProductStatusElementType {
    pub lang: Option<DtLang>,
    pub type_: ProductStatusType,
    pub content: String,
}
impl WithSerializer for ProductStatusElementType {
    type Serializer<'x> = quick_xml_serialize::ProductStatusElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::ProductStatusElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::ProductStatusElementTypeSerializerState::Init__),
            name: name.unwrap_or("PRODUCT_STATUS"),
            is_root,
        })
    }
}
impl WithDeserializer for ProductStatusElementType {
    type Deserializer = quick_xml_deserialize::ProductStatusElementTypeDeserializer;
}
#[derive(Debug)]
pub struct TypeClassificationGroupId {
    pub type_: Option<TypeClassificationGroupIdType>,
    pub content: String,
}
impl WithSerializer for TypeClassificationGroupId {
    type Serializer<'x> = quick_xml_serialize::TypeClassificationGroupIdSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::TypeClassificationGroupIdSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::TypeClassificationGroupIdSerializerState::Init__),
            name: name.unwrap_or("typeCLASSIFICATION_GROUP_ID"),
            is_root,
        })
    }
}
impl WithDeserializer for TypeClassificationGroupId {
    type Deserializer = quick_xml_deserialize::TypeClassificationGroupIdDeserializer;
}
#[derive(Debug)]
pub struct FeatureElementType {
    pub fname: Vec<DtMlstring>,
    pub fvalue: Vec<DtMlstring>,
    pub funit: Option<String>,
    pub fvalue_details: Vec<DtMlstring>,
}
impl WithSerializer for FeatureElementType {
    type Serializer<'x> = quick_xml_serialize::FeatureElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::FeatureElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::FeatureElementTypeSerializerState::Init__),
            name: name.unwrap_or("FEATURE"),
            is_root,
        })
    }
}
impl WithDeserializer for FeatureElementType {
    type Deserializer = quick_xml_deserialize::FeatureElementTypeDeserializer;
}
#[derive(Debug)]
pub enum DtPunit {
    Be,
    Bg,
    Bo,
    Bx,
    C62,
    Ca,
    Cl,
    Cmt,
    Cq,
    Cs,
    Ct,
    Dr,
    Grm,
    Kg,
    Kgm,
    Ltr,
    Mgm,
    Mlt,
    Mmt,
    Mtr,
    Pa,
    Pf,
    Pk,
    Pl,
    Pr,
    Pu,
    Rg,
    Rl,
    Ro,
    Sa,
    Set,
    St,
    Tn,
    Tu,
    Z2,
    Z3,
}
impl SerializeBytes for DtPunit {
    fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
        match self {
            Self::Be => Ok(Some(Cow::Borrowed("BE"))),
            Self::Bg => Ok(Some(Cow::Borrowed("BG"))),
            Self::Bo => Ok(Some(Cow::Borrowed("BO"))),
            Self::Bx => Ok(Some(Cow::Borrowed("BX"))),
            Self::C62 => Ok(Some(Cow::Borrowed("C62"))),
            Self::Ca => Ok(Some(Cow::Borrowed("CA"))),
            Self::Cl => Ok(Some(Cow::Borrowed("CL"))),
            Self::Cmt => Ok(Some(Cow::Borrowed("CMT"))),
            Self::Cq => Ok(Some(Cow::Borrowed("CQ"))),
            Self::Cs => Ok(Some(Cow::Borrowed("CS"))),
            Self::Ct => Ok(Some(Cow::Borrowed("CT"))),
            Self::Dr => Ok(Some(Cow::Borrowed("DR"))),
            Self::Grm => Ok(Some(Cow::Borrowed("GRM"))),
            Self::Kg => Ok(Some(Cow::Borrowed("KG"))),
            Self::Kgm => Ok(Some(Cow::Borrowed("KGM"))),
            Self::Ltr => Ok(Some(Cow::Borrowed("LTR"))),
            Self::Mgm => Ok(Some(Cow::Borrowed("MGM"))),
            Self::Mlt => Ok(Some(Cow::Borrowed("MLT"))),
            Self::Mmt => Ok(Some(Cow::Borrowed("MMT"))),
            Self::Mtr => Ok(Some(Cow::Borrowed("MTR"))),
            Self::Pa => Ok(Some(Cow::Borrowed("PA"))),
            Self::Pf => Ok(Some(Cow::Borrowed("PF"))),
            Self::Pk => Ok(Some(Cow::Borrowed("PK"))),
            Self::Pl => Ok(Some(Cow::Borrowed("PL"))),
            Self::Pr => Ok(Some(Cow::Borrowed("PR"))),
            Self::Pu => Ok(Some(Cow::Borrowed("PU"))),
            Self::Rg => Ok(Some(Cow::Borrowed("RG"))),
            Self::Rl => Ok(Some(Cow::Borrowed("RL"))),
            Self::Ro => Ok(Some(Cow::Borrowed("RO"))),
            Self::Sa => Ok(Some(Cow::Borrowed("SA"))),
            Self::Set => Ok(Some(Cow::Borrowed("SET"))),
            Self::St => Ok(Some(Cow::Borrowed("ST"))),
            Self::Tn => Ok(Some(Cow::Borrowed("TN"))),
            Self::Tu => Ok(Some(Cow::Borrowed("TU"))),
            Self::Z2 => Ok(Some(Cow::Borrowed("Z2"))),
            Self::Z3 => Ok(Some(Cow::Borrowed("Z3"))),
        }
    }
}
impl WithSerializeToBytes for DtPunit {}
impl DeserializeBytes for DtPunit {
    fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
        match bytes {
            b"BE" => Ok(Self::Be),
            b"BG" => Ok(Self::Bg),
            b"BO" => Ok(Self::Bo),
            b"BX" => Ok(Self::Bx),
            b"C62" => Ok(Self::C62),
            b"CA" => Ok(Self::Ca),
            b"CL" => Ok(Self::Cl),
            b"CMT" => Ok(Self::Cmt),
            b"CQ" => Ok(Self::Cq),
            b"CS" => Ok(Self::Cs),
            b"CT" => Ok(Self::Ct),
            b"DR" => Ok(Self::Dr),
            b"GRM" => Ok(Self::Grm),
            b"KG" => Ok(Self::Kg),
            b"KGM" => Ok(Self::Kgm),
            b"LTR" => Ok(Self::Ltr),
            b"MGM" => Ok(Self::Mgm),
            b"MLT" => Ok(Self::Mlt),
            b"MMT" => Ok(Self::Mmt),
            b"MTR" => Ok(Self::Mtr),
            b"PA" => Ok(Self::Pa),
            b"PF" => Ok(Self::Pf),
            b"PK" => Ok(Self::Pk),
            b"PL" => Ok(Self::Pl),
            b"PR" => Ok(Self::Pr),
            b"PU" => Ok(Self::Pu),
            b"RG" => Ok(Self::Rg),
            b"RL" => Ok(Self::Rl),
            b"RO" => Ok(Self::Ro),
            b"SA" => Ok(Self::Sa),
            b"SET" => Ok(Self::Set),
            b"ST" => Ok(Self::St),
            b"TN" => Ok(Self::Tn),
            b"TU" => Ok(Self::Tu),
            b"Z2" => Ok(Self::Z2),
            b"Z3" => Ok(Self::Z3),
            x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
                RawByteStr::from_slice(x),
            ))),
        }
    }
}
impl WithDeserializerFromBytes for DtPunit {}
#[derive(Debug)]
pub struct ProductPriceDetailsDatetimeElementType {
    pub type_: ProductPriceDetailsDatetimeType,
    pub date: String,
    pub time: Option<String>,
    pub timezone: Option<String>,
}
impl WithSerializer for ProductPriceDetailsDatetimeElementType {
    type Serializer<'x> = quick_xml_serialize::ProductPriceDetailsDatetimeElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok (quick_xml_serialize :: ProductPriceDetailsDatetimeElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: ProductPriceDetailsDatetimeElementTypeSerializerState :: Init__) , name : name . unwrap_or ("ProductPriceDetailsDatetime") , is_root , })
    }
}
impl WithDeserializer for ProductPriceDetailsDatetimeElementType {
    type Deserializer = quick_xml_deserialize::ProductPriceDetailsDatetimeElementTypeDeserializer;
}
#[derive(Debug)]
pub struct ProductPriceElementType {
    pub price_type: String,
    pub price_amount: f64,
    pub price_currency: Option<DtCurrencies>,
    pub tax: Option<f64>,
    pub price_factor: Option<f64>,
    pub lower_bound: Option<f64>,
    pub territory: Vec<String>,
}
impl WithSerializer for ProductPriceElementType {
    type Serializer<'x> = quick_xml_serialize::ProductPriceElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::ProductPriceElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::ProductPriceElementTypeSerializerState::Init__),
            name: name.unwrap_or("PRODUCT_PRICE"),
            is_root,
        })
    }
}
impl WithDeserializer for ProductPriceElementType {
    type Deserializer = quick_xml_deserialize::ProductPriceElementTypeDeserializer;
}
#[derive(Debug)]
pub struct UdxEdxfDiscountGroupElementType {
    pub content: Vec<UdxEdxfDiscountGroupElementTypeContent>,
}
#[derive(Debug)]
pub enum UdxEdxfDiscountGroupElementTypeContent {
    UdxEdxfDiscountGroupManufacturer(String),
    UdxEdxfDiscountGroupSupplier(String),
}
impl WithSerializer for UdxEdxfDiscountGroupElementType {
    type Serializer<'x> = quick_xml_serialize::UdxEdxfDiscountGroupElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(
            quick_xml_serialize::UdxEdxfDiscountGroupElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::UdxEdxfDiscountGroupElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("UDX.EDXF.DISCOUNT_GROUP"),
                is_root,
            },
        )
    }
}
impl WithSerializer for UdxEdxfDiscountGroupElementTypeContent {
    type Serializer<'x> = quick_xml_serialize::UdxEdxfDiscountGroupElementTypeContentSerializer<'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 :: UdxEdxfDiscountGroupElementTypeContentSerializer { value : self , state : Box :: new (quick_xml_serialize :: UdxEdxfDiscountGroupElementTypeContentSerializerState :: Init__) , })
    }
}
impl WithDeserializer for UdxEdxfDiscountGroupElementType {
    type Deserializer = quick_xml_deserialize::UdxEdxfDiscountGroupElementTypeDeserializer;
}
impl WithDeserializer for UdxEdxfDiscountGroupElementTypeContent {
    type Deserializer = quick_xml_deserialize::UdxEdxfDiscountGroupElementTypeContentDeserializer;
}
#[derive(Debug)]
pub struct UdxEdxfDeclarationElementType {
    pub type_: String,
    pub date: Option<String>,
    pub content: String,
}
impl WithSerializer for UdxEdxfDeclarationElementType {
    type Serializer<'x> = quick_xml_serialize::UdxEdxfDeclarationElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(
            quick_xml_serialize::UdxEdxfDeclarationElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::UdxEdxfDeclarationElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("UDX.EDXF.DECLARATION"),
                is_root,
            },
        )
    }
}
impl WithDeserializer for UdxEdxfDeclarationElementType {
    type Deserializer = quick_xml_deserialize::UdxEdxfDeclarationElementTypeDeserializer;
}
#[derive(Debug)]
pub struct UdxEdxfAdditionalFactorsElementType {
    pub udx_edxf_additional_price_factor: f64,
    pub udx_edxf_additional_factor_info: DtMlstring,
}
impl WithSerializer for UdxEdxfAdditionalFactorsElementType {
    type Serializer<'x> = quick_xml_serialize::UdxEdxfAdditionalFactorsElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(
            quick_xml_serialize::UdxEdxfAdditionalFactorsElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::UdxEdxfAdditionalFactorsElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("UDX.EDXF.ADDITIONAL_FACTORS"),
                is_root,
            },
        )
    }
}
impl WithDeserializer for UdxEdxfAdditionalFactorsElementType {
    type Deserializer = quick_xml_deserialize::UdxEdxfAdditionalFactorsElementTypeDeserializer;
}
#[derive(Debug)]
pub struct UdxEdxfCountryBranchNumbersElementType {
    pub udx_edxf_country_branch_number:
        Vec<UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementType>,
}
impl WithSerializer for UdxEdxfCountryBranchNumbersElementType {
    type Serializer<'x> = quick_xml_serialize::UdxEdxfCountryBranchNumbersElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok (quick_xml_serialize :: UdxEdxfCountryBranchNumbersElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: UdxEdxfCountryBranchNumbersElementTypeSerializerState :: Init__) , name : name . unwrap_or ("UDX.EDXF.COUNTRY_BRANCH_NUMBERS") , is_root , })
    }
}
impl WithDeserializer for UdxEdxfCountryBranchNumbersElementType {
    type Deserializer = quick_xml_deserialize::UdxEdxfCountryBranchNumbersElementTypeDeserializer;
}
#[derive(Debug)]
pub struct UdxEdxfCountryBranchSupplierIdsElementType {
    pub udx_edxf_country_branch_supplier_id:
        Vec<UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementType>,
}
impl WithSerializer for UdxEdxfCountryBranchSupplierIdsElementType {
    type Serializer<'x> =
        quick_xml_serialize::UdxEdxfCountryBranchSupplierIdsElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok (quick_xml_serialize :: UdxEdxfCountryBranchSupplierIdsElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: UdxEdxfCountryBranchSupplierIdsElementTypeSerializerState :: Init__) , name : name . unwrap_or ("UDX.EDXF.COUNTRY_BRANCH_SUPPLIER_IDS") , is_root , })
    }
}
impl WithDeserializer for UdxEdxfCountryBranchSupplierIdsElementType {
    type Deserializer =
        quick_xml_deserialize::UdxEdxfCountryBranchSupplierIdsElementTypeDeserializer;
}
#[derive(Debug)]
pub struct UdxEdxfPackingUnitsElementType {
    pub udx_edxf_packing_unit: Vec<UdxEdxfPackingUnitElementType>,
}
impl WithSerializer for UdxEdxfPackingUnitsElementType {
    type Serializer<'x> = quick_xml_serialize::UdxEdxfPackingUnitsElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(
            quick_xml_serialize::UdxEdxfPackingUnitsElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::UdxEdxfPackingUnitsElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("UDX.EDXF.PACKING_UNITS"),
                is_root,
            },
        )
    }
}
impl WithDeserializer for UdxEdxfPackingUnitsElementType {
    type Deserializer = quick_xml_deserialize::UdxEdxfPackingUnitsElementTypeDeserializer;
}
#[derive(Debug)]
pub struct UdxEdxfProductLogisticDetailsElementType {
    pub udx_edxf_netweight: Option<f64>,
    pub udx_edxf_region_of_origin: Option<String>,
}
impl WithSerializer for UdxEdxfProductLogisticDetailsElementType {
    type Serializer<'x> =
        quick_xml_serialize::UdxEdxfProductLogisticDetailsElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok (quick_xml_serialize :: UdxEdxfProductLogisticDetailsElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: UdxEdxfProductLogisticDetailsElementTypeSerializerState :: Init__) , name : name . unwrap_or ("UDX.EDXF.PRODUCT_LOGISTIC_DETAILS") , is_root , })
    }
}
impl WithDeserializer for UdxEdxfProductLogisticDetailsElementType {
    type Deserializer = quick_xml_deserialize::UdxEdxfProductLogisticDetailsElementTypeDeserializer;
}
#[derive(Debug)]
pub struct UdxEdxfReachElementType {
    pub udx_edxf_reach_listdate: Option<String>,
    pub udx_edxf_reach_info: String,
}
impl WithSerializer for UdxEdxfReachElementType {
    type Serializer<'x> = quick_xml_serialize::UdxEdxfReachElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::UdxEdxfReachElementTypeSerializer {
            value: self,
            state: Box::new(quick_xml_serialize::UdxEdxfReachElementTypeSerializerState::Init__),
            name: name.unwrap_or("UDX.EDXF.REACH"),
            is_root,
        })
    }
}
impl WithDeserializer for UdxEdxfReachElementType {
    type Deserializer = quick_xml_deserialize::UdxEdxfReachElementTypeDeserializer;
}
#[derive(Debug)]
pub struct UdxEdxfSurchargeListElementType {
    pub udx_edxf_surcharge: Vec<UdxEdxfSurchargeElementType>,
}
impl WithSerializer for UdxEdxfSurchargeListElementType {
    type Serializer<'x> = quick_xml_serialize::UdxEdxfSurchargeListElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(
            quick_xml_serialize::UdxEdxfSurchargeListElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::UdxEdxfSurchargeListElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("UDX.EDXF.SURCHARGE_LIST"),
                is_root,
            },
        )
    }
}
impl WithDeserializer for UdxEdxfSurchargeListElementType {
    type Deserializer = quick_xml_deserialize::UdxEdxfSurchargeListElementTypeDeserializer;
}
#[derive(Debug)]
pub enum ProductReferenceType {
    Accessories,
    BaseProduct,
    ConsistsOf,
    DiffOrderunit,
    Followup,
    Mandatory,
    Similar,
    Select,
    Sparepart,
    Others,
}
impl SerializeBytes for ProductReferenceType {
    fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
        match self {
            Self::Accessories => Ok(Some(Cow::Borrowed("accessories"))),
            Self::BaseProduct => Ok(Some(Cow::Borrowed("base_product"))),
            Self::ConsistsOf => Ok(Some(Cow::Borrowed("consists_of"))),
            Self::DiffOrderunit => Ok(Some(Cow::Borrowed("diff_orderunit"))),
            Self::Followup => Ok(Some(Cow::Borrowed("followup"))),
            Self::Mandatory => Ok(Some(Cow::Borrowed("mandatory"))),
            Self::Similar => Ok(Some(Cow::Borrowed("similar"))),
            Self::Select => Ok(Some(Cow::Borrowed("select"))),
            Self::Sparepart => Ok(Some(Cow::Borrowed("sparepart"))),
            Self::Others => Ok(Some(Cow::Borrowed("others"))),
        }
    }
}
impl WithSerializeToBytes for ProductReferenceType {}
impl DeserializeBytes for ProductReferenceType {
    fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
        match bytes {
            b"accessories" => Ok(Self::Accessories),
            b"base_product" => Ok(Self::BaseProduct),
            b"consists_of" => Ok(Self::ConsistsOf),
            b"diff_orderunit" => Ok(Self::DiffOrderunit),
            b"followup" => Ok(Self::Followup),
            b"mandatory" => Ok(Self::Mandatory),
            b"similar" => Ok(Self::Similar),
            b"select" => Ok(Self::Select),
            b"sparepart" => Ok(Self::Sparepart),
            b"others" => Ok(Self::Others),
            x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
                RawByteStr::from_slice(x),
            ))),
        }
    }
}
impl WithDeserializerFromBytes for ProductReferenceType {}
#[derive(Debug)]
pub struct CustomsTariffNumberElementType {
    pub customs_number: String,
}
impl WithSerializer for CustomsTariffNumberElementType {
    type Serializer<'x> = quick_xml_serialize::CustomsTariffNumberElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(
            quick_xml_serialize::CustomsTariffNumberElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::CustomsTariffNumberElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("CUSTOMS_TARIFF_NUMBER"),
                is_root,
            },
        )
    }
}
impl WithDeserializer for CustomsTariffNumberElementType {
    type Deserializer = quick_xml_deserialize::CustomsTariffNumberElementTypeDeserializer;
}
#[derive(Debug)]
pub enum MimePurposeElementType {
    DataSheet,
    Detail,
    Icon,
    Logo,
    Normal,
    SafetyDataSheet,
    Thumbnail,
    Others,
}
impl SerializeBytes for MimePurposeElementType {
    fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
        match self {
            Self::DataSheet => Ok(Some(Cow::Borrowed("data_sheet"))),
            Self::Detail => Ok(Some(Cow::Borrowed("detail"))),
            Self::Icon => Ok(Some(Cow::Borrowed("icon"))),
            Self::Logo => Ok(Some(Cow::Borrowed("logo"))),
            Self::Normal => Ok(Some(Cow::Borrowed("normal"))),
            Self::SafetyDataSheet => Ok(Some(Cow::Borrowed("safety_data_sheet"))),
            Self::Thumbnail => Ok(Some(Cow::Borrowed("thumbnail"))),
            Self::Others => Ok(Some(Cow::Borrowed("others"))),
        }
    }
}
impl WithSerializeToBytes for MimePurposeElementType {}
impl DeserializeBytes for MimePurposeElementType {
    fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
        match bytes {
            b"data_sheet" => Ok(Self::DataSheet),
            b"detail" => Ok(Self::Detail),
            b"icon" => Ok(Self::Icon),
            b"logo" => Ok(Self::Logo),
            b"normal" => Ok(Self::Normal),
            b"safety_data_sheet" => Ok(Self::SafetyDataSheet),
            b"thumbnail" => Ok(Self::Thumbnail),
            b"others" => Ok(Self::Others),
            x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
                RawByteStr::from_slice(x),
            ))),
        }
    }
}
impl WithDeserializerFromBytes for MimePurposeElementType {}
#[derive(Debug)]
pub enum ProductStatusType {
    Bargain,
    CoreProduct,
    New,
    NewProduct,
    OldProduct,
    Refurbished,
    Used,
    Others,
}
impl SerializeBytes for ProductStatusType {
    fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
        match self {
            Self::Bargain => Ok(Some(Cow::Borrowed("bargain"))),
            Self::CoreProduct => Ok(Some(Cow::Borrowed("core_product"))),
            Self::New => Ok(Some(Cow::Borrowed("new"))),
            Self::NewProduct => Ok(Some(Cow::Borrowed("new_product"))),
            Self::OldProduct => Ok(Some(Cow::Borrowed("old_product"))),
            Self::Refurbished => Ok(Some(Cow::Borrowed("refurbished"))),
            Self::Used => Ok(Some(Cow::Borrowed("used"))),
            Self::Others => Ok(Some(Cow::Borrowed("others"))),
        }
    }
}
impl WithSerializeToBytes for ProductStatusType {}
impl DeserializeBytes for ProductStatusType {
    fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
        match bytes {
            b"bargain" => Ok(Self::Bargain),
            b"core_product" => Ok(Self::CoreProduct),
            b"new" => Ok(Self::New),
            b"new_product" => Ok(Self::NewProduct),
            b"old_product" => Ok(Self::OldProduct),
            b"refurbished" => Ok(Self::Refurbished),
            b"used" => Ok(Self::Used),
            b"others" => Ok(Self::Others),
            x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
                RawByteStr::from_slice(x),
            ))),
        }
    }
}
impl WithDeserializerFromBytes for ProductStatusType {}
#[derive(Debug)]
pub enum TypeClassificationGroupIdType {
    Flat,
    Hierarchy,
}
impl SerializeBytes for TypeClassificationGroupIdType {
    fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
        match self {
            Self::Flat => Ok(Some(Cow::Borrowed("flat"))),
            Self::Hierarchy => Ok(Some(Cow::Borrowed("hierarchy"))),
        }
    }
}
impl WithSerializeToBytes for TypeClassificationGroupIdType {}
impl DeserializeBytes for TypeClassificationGroupIdType {
    fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
        match bytes {
            b"flat" => Ok(Self::Flat),
            b"hierarchy" => Ok(Self::Hierarchy),
            x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
                RawByteStr::from_slice(x),
            ))),
        }
    }
}
impl WithDeserializerFromBytes for TypeClassificationGroupIdType {}
#[derive(Debug)]
pub enum ProductPriceDetailsDatetimeType {
    ValidStartDate,
    ValidEndDate,
}
impl SerializeBytes for ProductPriceDetailsDatetimeType {
    fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
        match self {
            Self::ValidStartDate => Ok(Some(Cow::Borrowed("valid_start_date"))),
            Self::ValidEndDate => Ok(Some(Cow::Borrowed("valid_end_date"))),
        }
    }
}
impl WithSerializeToBytes for ProductPriceDetailsDatetimeType {}
impl DeserializeBytes for ProductPriceDetailsDatetimeType {
    fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
        match bytes {
            b"valid_start_date" => Ok(Self::ValidStartDate),
            b"valid_end_date" => Ok(Self::ValidEndDate),
            x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
                RawByteStr::from_slice(x),
            ))),
        }
    }
}
impl WithDeserializerFromBytes for ProductPriceDetailsDatetimeType {}
#[derive(Debug)]
pub struct UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementType {
    pub type_: String,
    pub country: String,
    pub content: f64,
}
impl WithSerializer for UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementType {
    type Serializer < 'x > = quick_xml_serialize :: UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeSerializer < 'x > ;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok (quick_xml_serialize :: UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeSerializerState :: Init__) , name : name . unwrap_or ("UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumber") , is_root , })
    }
}
impl WithDeserializer for UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementType {
    type Deserializer = quick_xml_deserialize :: UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeDeserializer ;
}
#[derive(Debug)]
pub struct UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementType {
    pub type_: String,
    pub country: String,
    pub content: f64,
}
impl WithSerializer for UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementType {
    type Serializer < 'x > = quick_xml_serialize :: UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeSerializer < 'x > ;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok (quick_xml_serialize :: UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeSerializer { value : self , state : Box :: new (quick_xml_serialize :: UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeSerializerState :: Init__) , name : name . unwrap_or ("UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierId") , is_root , })
    }
}
impl WithDeserializer for UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementType {
    type Deserializer = quick_xml_deserialize :: UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeDeserializer ;
}
#[derive(Debug)]
pub struct UdxEdxfPackingUnitElementType {
    pub udx_edxf_quantity_min: f32,
    pub udx_edxf_quantity_max: Option<f32>,
    pub udx_edxf_packing_unit_code: DtPunit,
    pub udx_edxf_packing_unit_name: Vec<DtMlstring>,
    pub udx_edxf_package_break: Option<String>,
    pub udx_edxf_volume: Option<f64>,
    pub udx_edxf_weight: Option<f64>,
    pub udx_edxf_length: Option<f64>,
    pub udx_edxf_width: Option<f64>,
    pub udx_edxf_depth: Option<f64>,
    pub udx_edxf_diameter: Option<f64>,
    pub udx_edxf_gtin: Option<String>,
    pub udx_edxf_gs_1128: Option<String>,
}
impl WithSerializer for UdxEdxfPackingUnitElementType {
    type Serializer<'x> = quick_xml_serialize::UdxEdxfPackingUnitElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(
            quick_xml_serialize::UdxEdxfPackingUnitElementTypeSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::UdxEdxfPackingUnitElementTypeSerializerState::Init__,
                ),
                name: name.unwrap_or("UDX.EDXF.PACKING_UNIT"),
                is_root,
            },
        )
    }
}
impl WithDeserializer for UdxEdxfPackingUnitElementType {
    type Deserializer = quick_xml_deserialize::UdxEdxfPackingUnitElementTypeDeserializer;
}
#[derive(Debug)]
pub struct UdxEdxfSurchargeElementType {
    pub content: Vec<UdxEdxfSurchargeElementTypeContent>,
}
#[derive(Debug)]
pub enum UdxEdxfSurchargeElementTypeContent {
    UdxEdxfSurchargeType(String),
    UdxEdxfSurchargeManner(String),
    UdxEdxfSurchargePercentage(f64),
    UdxEdxfSurchargePriceAmount(f64),
    UdxEdxfSurchargeCalculation(f64),
    UdxEdxfMaterialBasis(f64),
    UdxEdxfMaterialBasisWeight(f64),
    UdxEdxfMaterialBasisSurchargeThreshold(f64),
    UdxEdxfMaterialBasisSurchargeShutter(i32),
    UdxEdxfMaterialBasisSurchargeCredit(i32),
    UdxEdxfMaterialBasisSurchargeTable(DtMlstring),
}
impl WithSerializer for UdxEdxfSurchargeElementType {
    type Serializer<'x> = quick_xml_serialize::UdxEdxfSurchargeElementTypeSerializer<'x>;
    fn serializer<'ser>(
        &'ser self,
        name: Option<&'ser str>,
        is_root: bool,
    ) -> Result<Self::Serializer<'ser>, Error> {
        Ok(quick_xml_serialize::UdxEdxfSurchargeElementTypeSerializer {
            value: self,
            state: Box::new(
                quick_xml_serialize::UdxEdxfSurchargeElementTypeSerializerState::Init__,
            ),
            name: name.unwrap_or("UDX.EDXF.SURCHARGE"),
            is_root,
        })
    }
}
impl WithSerializer for UdxEdxfSurchargeElementTypeContent {
    type Serializer<'x> = quick_xml_serialize::UdxEdxfSurchargeElementTypeContentSerializer<'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::UdxEdxfSurchargeElementTypeContentSerializer {
                value: self,
                state: Box::new(
                    quick_xml_serialize::UdxEdxfSurchargeElementTypeContentSerializerState::Init__,
                ),
            },
        )
    }
}
impl WithDeserializer for UdxEdxfSurchargeElementType {
    type Deserializer = quick_xml_deserialize::UdxEdxfSurchargeElementTypeDeserializer;
}
impl WithDeserializer for UdxEdxfSurchargeElementTypeContent {
    type Deserializer = quick_xml_deserialize::UdxEdxfSurchargeElementTypeContentDeserializer;
}
pub mod quick_xml_deserialize {
    use core::mem::replace;
    use xsd_parser_types::quick_xml::{
        BytesStart, ContentDeserializer, DeserializeHelper, Deserializer, DeserializerArtifact,
        DeserializerEvent, DeserializerOutput, DeserializerResult, ElementHandlerOutput, Error,
        ErrorKind, Event, RawByteStr, WithDeserializer,
    };
    #[derive(Debug)]
    pub struct BmecatElementTypeDeserializer {
        version: super::TypeBmEcatVersion,
        content: Vec<super::BmecatElementTypeContent>,
        state__: Box<BmecatElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum BmecatElementTypeDeserializerState {
        Init__,
        Next__,
        Content__(<super::BmecatElementTypeContent as WithDeserializer>::Deserializer),
        Unknown__,
    }
    impl BmecatElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut version: Option<super::TypeBmEcatVersion> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"version")
                ) {
                    helper.read_attrib(&mut version, b"version", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                version: version.ok_or_else(|| ErrorKind::MissingAttribute("version".into()))?,
                content: Vec::new(),
                state__: Box::new(BmecatElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: BmecatElementTypeDeserializerState,
        ) -> Result<(), Error> {
            if let BmecatElementTypeDeserializerState::Content__(deserializer) = state {
                self.store_content(deserializer.finish(helper)?)?;
            }
            Ok(())
        }
        fn store_content(&mut self, value: super::BmecatElementTypeContent) -> Result<(), Error> {
            self.content.push(value);
            Ok(())
        }
        fn handle_content<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::BmecatElementTypeContent>,
            fallback: &mut Option<BmecatElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use BmecatElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = fallback.take().unwrap_or(S::Next__);
                return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_content(data)?;
                    *self.state__ = S::Next__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    if self.content.len() < 1usize {
                        *fallback = Some(S::Content__(deserializer));
                        *self.state__ = S::Next__;
                        Ok(ElementHandlerOutput::from_event(event, allow_any))
                    } else {
                        *self.state__ = S::Content__(deserializer);
                        Ok(ElementHandlerOutput::from_event_end(event, allow_any))
                    }
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::BmecatElementType> for BmecatElementTypeDeserializer {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::BmecatElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::BmecatElementType> {
            use BmecatElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::Content__(deserializer), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_content(helper, 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(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (state @ (S::Init__ | S::Next__), event) => {
                        fallback.get_or_insert(state);
                        let output = <super::BmecatElementTypeContent as WithDeserializer>::init(
                            helper, event,
                        )?;
                        match self.handle_content(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                }
            };
            if let Some(fallback) = fallback {
                *self.state__ = fallback;
            }
            let artifact = DeserializerArtifact::Deserializer(self);
            Ok(DeserializerOutput {
                artifact,
                event,
                allow_any,
            })
        }
        fn finish(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::BmecatElementType, Error> {
            let state = replace(
                &mut *self.state__,
                BmecatElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::BmecatElementType {
                version: self.version,
                content: helper.finish_vec(1usize, Some(2usize), self.content)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct BmecatElementTypeContentDeserializer {
        state__: Box<BmecatElementTypeContentDeserializerState>,
    }
    #[derive(Debug)]
    pub enum BmecatElementTypeContentDeserializerState {
        Init__,
        Header(
            Option<super::HeaderElementType>,
            Option<<super::HeaderElementType as WithDeserializer>::Deserializer>,
            Option<<super::HeaderElementType as WithDeserializer>::Deserializer>,
        ),
        TNewCatalog(
            Option<super::TNewCatalogElementType>,
            Option<<super::TNewCatalogElementType as WithDeserializer>::Deserializer>,
            Option<<super::TNewCatalogElementType as WithDeserializer>::Deserializer>,
        ),
        TUpdateProducts(
            Option<super::TUpdateProductsElementType>,
            Option<<super::TUpdateProductsElementType as WithDeserializer>::Deserializer>,
            Option<<super::TUpdateProductsElementType as WithDeserializer>::Deserializer>,
        ),
        TUpdatePrices(
            Option<super::TUpdatePricesElementType>,
            Option<<super::TUpdatePricesElementType as WithDeserializer>::Deserializer>,
            Option<<super::TUpdatePricesElementType as WithDeserializer>::Deserializer>,
        ),
        Done__(super::BmecatElementTypeContent),
        Unknown__,
    }
    impl BmecatElementTypeContentDeserializer {
        fn find_suitable<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            if let Event::Start(x) | Event::Empty(x) = &event {
                if matches!(
                    helper.resolve_local_name(x.name(), &super::NS_UNNAMED_5),
                    Some(b"HEADER")
                ) {
                    let output =
                        <super::HeaderElementType as WithDeserializer>::init(helper, event)?;
                    return self.handle_header(helper, Default::default(), None, output);
                }
                if matches!(
                    helper.resolve_local_name(x.name(), &super::NS_UNNAMED_5),
                    Some(b"T_NEW_CATALOG")
                ) {
                    let output =
                        <super::TNewCatalogElementType as WithDeserializer>::init(helper, event)?;
                    return self.handle_t_new_catalog(helper, Default::default(), None, output);
                }
                if matches!(
                    helper.resolve_local_name(x.name(), &super::NS_UNNAMED_5),
                    Some(b"T_UPDATE_PRODUCTS")
                ) {
                    let output = <super::TUpdateProductsElementType as WithDeserializer>::init(
                        helper, event,
                    )?;
                    return self.handle_t_update_products(helper, Default::default(), None, output);
                }
                if matches!(
                    helper.resolve_local_name(x.name(), &super::NS_UNNAMED_5),
                    Some(b"T_UPDATE_PRICES")
                ) {
                    let output =
                        <super::TUpdatePricesElementType as WithDeserializer>::init(helper, event)?;
                    return self.handle_t_update_prices(helper, Default::default(), None, output);
                }
            }
            *self.state__ = BmecatElementTypeContentDeserializerState::Init__;
            Ok(ElementHandlerOutput::return_to_parent(event, false))
        }
        fn finish_state(
            helper: &mut DeserializeHelper,
            state: BmecatElementTypeContentDeserializerState,
        ) -> Result<super::BmecatElementTypeContent, Error> {
            use BmecatElementTypeContentDeserializerState as S;
            match state {
                S::Init__ => Err(ErrorKind::MissingContent.into()),
                S::Header(mut values, None, deserializer) => {
                    if let Some(deserializer) = deserializer {
                        let value = deserializer.finish(helper)?;
                        Self::store_header(&mut values, value)?;
                    }
                    Ok(super::BmecatElementTypeContent::Header(
                        helper.finish_element("HEADER", values)?,
                    ))
                }
                S::TNewCatalog(mut values, None, deserializer) => {
                    if let Some(deserializer) = deserializer {
                        let value = deserializer.finish(helper)?;
                        Self::store_t_new_catalog(&mut values, value)?;
                    }
                    Ok(super::BmecatElementTypeContent::TNewCatalog(
                        helper.finish_element("T_NEW_CATALOG", values)?,
                    ))
                }
                S::TUpdateProducts(mut values, None, deserializer) => {
                    if let Some(deserializer) = deserializer {
                        let value = deserializer.finish(helper)?;
                        Self::store_t_update_products(&mut values, value)?;
                    }
                    Ok(super::BmecatElementTypeContent::TUpdateProducts(
                        helper.finish_element("T_UPDATE_PRODUCTS", values)?,
                    ))
                }
                S::TUpdatePrices(mut values, None, deserializer) => {
                    if let Some(deserializer) = deserializer {
                        let value = deserializer.finish(helper)?;
                        Self::store_t_update_prices(&mut values, value)?;
                    }
                    Ok(super::BmecatElementTypeContent::TUpdatePrices(
                        helper.finish_element("T_UPDATE_PRICES", values)?,
                    ))
                }
                S::Done__(data) => Ok(data),
                _ => unreachable!(),
            }
        }
        fn store_header(
            values: &mut Option<super::HeaderElementType>,
            value: super::HeaderElementType,
        ) -> Result<(), Error> {
            if values.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"HEADER",
                )))?;
            }
            *values = Some(value);
            Ok(())
        }
        fn store_t_new_catalog(
            values: &mut Option<super::TNewCatalogElementType>,
            value: super::TNewCatalogElementType,
        ) -> Result<(), Error> {
            if values.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"T_NEW_CATALOG",
                )))?;
            }
            *values = Some(value);
            Ok(())
        }
        fn store_t_update_products(
            values: &mut Option<super::TUpdateProductsElementType>,
            value: super::TUpdateProductsElementType,
        ) -> Result<(), Error> {
            if values.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"T_UPDATE_PRODUCTS",
                )))?;
            }
            *values = Some(value);
            Ok(())
        }
        fn store_t_update_prices(
            values: &mut Option<super::TUpdatePricesElementType>,
            value: super::TUpdatePricesElementType,
        ) -> Result<(), Error> {
            if values.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"T_UPDATE_PRICES",
                )))?;
            }
            *values = Some(value);
            Ok(())
        }
        fn handle_header<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            mut values: Option<super::HeaderElementType>,
            fallback: Option<<super::HeaderElementType as WithDeserializer>::Deserializer>,
            output: DeserializerOutput<'de, super::HeaderElementType>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use BmecatElementTypeContentDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
            }
            if let Some(deserializer) = fallback {
                let data = deserializer.finish(helper)?;
                Self::store_header(&mut values, data)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    Self::store_header(&mut values, data)?;
                    let data = Self::finish_state(helper, S::Header(values, None, None))?;
                    *self.state__ = S::Done__(data);
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::Header(values, None, Some(deserializer));
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
            }
        }
        fn handle_t_new_catalog<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            mut values: Option<super::TNewCatalogElementType>,
            fallback: Option<<super::TNewCatalogElementType as WithDeserializer>::Deserializer>,
            output: DeserializerOutput<'de, super::TNewCatalogElementType>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use BmecatElementTypeContentDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
            }
            if let Some(deserializer) = fallback {
                let data = deserializer.finish(helper)?;
                Self::store_t_new_catalog(&mut values, data)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    Self::store_t_new_catalog(&mut values, data)?;
                    let data = Self::finish_state(helper, S::TNewCatalog(values, None, None))?;
                    *self.state__ = S::Done__(data);
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::TNewCatalog(values, None, Some(deserializer));
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
            }
        }
        fn handle_t_update_products<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            mut values: Option<super::TUpdateProductsElementType>,
            fallback: Option<<super::TUpdateProductsElementType as WithDeserializer>::Deserializer>,
            output: DeserializerOutput<'de, super::TUpdateProductsElementType>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use BmecatElementTypeContentDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
            }
            if let Some(deserializer) = fallback {
                let data = deserializer.finish(helper)?;
                Self::store_t_update_products(&mut values, data)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    Self::store_t_update_products(&mut values, data)?;
                    let data = Self::finish_state(helper, S::TUpdateProducts(values, None, None))?;
                    *self.state__ = S::Done__(data);
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::TUpdateProducts(values, None, Some(deserializer));
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
            }
        }
        fn handle_t_update_prices<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            mut values: Option<super::TUpdatePricesElementType>,
            fallback: Option<<super::TUpdatePricesElementType as WithDeserializer>::Deserializer>,
            output: DeserializerOutput<'de, super::TUpdatePricesElementType>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use BmecatElementTypeContentDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
            }
            if let Some(deserializer) = fallback {
                let data = deserializer.finish(helper)?;
                Self::store_t_update_prices(&mut values, data)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    Self::store_t_update_prices(&mut values, data)?;
                    let data = Self::finish_state(helper, S::TUpdatePrices(values, None, None))?;
                    *self.state__ = S::Done__(data);
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::TUpdatePrices(values, None, Some(deserializer));
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::BmecatElementTypeContent>
        for BmecatElementTypeContentDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::BmecatElementTypeContent> {
            let deserializer = Self {
                state__: Box::new(BmecatElementTypeContentDeserializerState::Init__),
            };
            let mut output = deserializer.next(helper, event)?;
            output.artifact = match output.artifact {
                DeserializerArtifact::Deserializer(x)
                    if matches!(
                        &*x.state__,
                        BmecatElementTypeContentDeserializerState::Init__
                    ) =>
                {
                    DeserializerArtifact::None
                }
                artifact => artifact,
            };
            Ok(output)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::BmecatElementTypeContent> {
            use BmecatElementTypeContentDeserializerState as S;
            let mut event = event;
            let (event, allow_any) = loop {
                let state = replace(&mut *self.state__, S::Unknown__);
                event = match (state, event) {
                    (S::Unknown__, _) => unreachable!(),
                    (S::Header(values, fallback, Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_header(helper, values, fallback, output)? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (S::TNewCatalog(values, fallback, Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_t_new_catalog(helper, values, fallback, output)? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (S::TUpdateProducts(values, fallback, Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_t_update_products(helper, values, fallback, output)? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (S::TUpdatePrices(values, fallback, Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_t_update_prices(helper, values, fallback, output)? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (state, event @ Event::End(_)) => {
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(Self::finish_state(
                                helper, state,
                            )?),
                            event: DeserializerEvent::Continue(event),
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => match self.find_suitable(helper, event)? {
                        ElementHandlerOutput::Break { event, allow_any } => {
                            break (event, allow_any)
                        }
                        ElementHandlerOutput::Continue { event, .. } => event,
                    },
                    (
                        S::Header(values, fallback, None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"HEADER",
                            false,
                        )?;
                        match self.handle_header(helper, values, fallback, output)? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::TNewCatalog(values, fallback, None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"T_NEW_CATALOG",
                            false,
                        )?;
                        match self.handle_t_new_catalog(helper, values, fallback, output)? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::TUpdateProducts(values, fallback, None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"T_UPDATE_PRODUCTS",
                            false,
                        )?;
                        match self.handle_t_update_products(helper, values, fallback, output)? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::TUpdatePrices(values, fallback, None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"T_UPDATE_PRICES",
                            false,
                        )?;
                        match self.handle_t_update_prices(helper, values, fallback, output)? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (state @ S::Done__(_), event) => {
                        *self.state__ = state;
                        break (DeserializerEvent::Continue(event), false);
                    }
                    (state, event) => {
                        *self.state__ = state;
                        break (DeserializerEvent::Continue(event), false);
                    }
                }
            };
            let artifact = if matches!(&*self.state__, S::Done__(_)) {
                DeserializerArtifact::Data(self.finish(helper)?)
            } else {
                DeserializerArtifact::Deserializer(self)
            };
            Ok(DeserializerOutput {
                artifact,
                event,
                allow_any,
            })
        }
        fn finish(
            self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::BmecatElementTypeContent, Error> {
            Self::finish_state(helper, *self.state__)
        }
    }
    #[derive(Debug)]
    pub struct HeaderElementTypeDeserializer {
        generator_info: Option<String>,
        catalog: Option<super::CatalogElementType>,
        buyer: Option<super::BuyerElementType>,
        supplier: Option<super::SupplierElementType>,
        user_defined_extensions: Option<super::UdxHeader>,
        state__: Box<HeaderElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum HeaderElementTypeDeserializerState {
        Init__,
        GeneratorInfo(Option<<String as WithDeserializer>::Deserializer>),
        Catalog(Option<<super::CatalogElementType as WithDeserializer>::Deserializer>),
        Buyer(Option<<super::BuyerElementType as WithDeserializer>::Deserializer>),
        Supplier(Option<<super::SupplierElementType as WithDeserializer>::Deserializer>),
        UserDefinedExtensions(Option<<super::UdxHeader as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl HeaderElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                generator_info: None,
                catalog: None,
                buyer: None,
                supplier: None,
                user_defined_extensions: None,
                state__: Box::new(HeaderElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: HeaderElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use HeaderElementTypeDeserializerState as S;
            match state {
                S::GeneratorInfo(Some(deserializer)) => {
                    self.store_generator_info(deserializer.finish(helper)?)?
                }
                S::Catalog(Some(deserializer)) => {
                    self.store_catalog(deserializer.finish(helper)?)?
                }
                S::Buyer(Some(deserializer)) => self.store_buyer(deserializer.finish(helper)?)?,
                S::Supplier(Some(deserializer)) => {
                    self.store_supplier(deserializer.finish(helper)?)?
                }
                S::UserDefinedExtensions(Some(deserializer)) => {
                    self.store_user_defined_extensions(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_generator_info(&mut self, value: String) -> Result<(), Error> {
            if self.generator_info.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"GENERATOR_INFO",
                )))?;
            }
            self.generator_info = Some(value);
            Ok(())
        }
        fn store_catalog(&mut self, value: super::CatalogElementType) -> Result<(), Error> {
            if self.catalog.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"CATALOG",
                )))?;
            }
            self.catalog = Some(value);
            Ok(())
        }
        fn store_buyer(&mut self, value: super::BuyerElementType) -> Result<(), Error> {
            if self.buyer.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"BUYER",
                )))?;
            }
            self.buyer = Some(value);
            Ok(())
        }
        fn store_supplier(&mut self, value: super::SupplierElementType) -> Result<(), Error> {
            if self.supplier.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"SUPPLIER",
                )))?;
            }
            self.supplier = Some(value);
            Ok(())
        }
        fn store_user_defined_extensions(&mut self, value: super::UdxHeader) -> Result<(), Error> {
            if self.user_defined_extensions.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"USER_DEFINED_EXTENSIONS",
                )))?;
            }
            self.user_defined_extensions = Some(value);
            Ok(())
        }
        fn handle_generator_info<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<HeaderElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use HeaderElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Catalog(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_generator_info(data)?;
                    *self.state__ = S::Catalog(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::GeneratorInfo(Some(deserializer)));
                    *self.state__ = S::Catalog(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_catalog<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::CatalogElementType>,
            fallback: &mut Option<HeaderElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use HeaderElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::Catalog(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_catalog(data)?;
                    *self.state__ = S::Buyer(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Catalog(Some(deserializer)));
                    *self.state__ = S::Buyer(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_buyer<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::BuyerElementType>,
            fallback: &mut Option<HeaderElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use HeaderElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::Buyer(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_buyer(data)?;
                    *self.state__ = S::Supplier(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Buyer(Some(deserializer)));
                    *self.state__ = S::Supplier(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_supplier<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::SupplierElementType>,
            fallback: &mut Option<HeaderElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use HeaderElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::Supplier(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_supplier(data)?;
                    *self.state__ = S::UserDefinedExtensions(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Supplier(Some(deserializer)));
                    *self.state__ = S::UserDefinedExtensions(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_user_defined_extensions<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::UdxHeader>,
            fallback: &mut Option<HeaderElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use HeaderElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::UserDefinedExtensions(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_user_defined_extensions(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UserDefinedExtensions(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::HeaderElementType> for HeaderElementTypeDeserializer {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::HeaderElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::HeaderElementType> {
            use HeaderElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::GeneratorInfo(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_generator_info(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Catalog(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_catalog(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Buyer(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_buyer(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Supplier(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_supplier(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UserDefinedExtensions(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_user_defined_extensions(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::GeneratorInfo(None);
                        event
                    }
                    (S::GeneratorInfo(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"GENERATOR_INFO",
                            false,
                        )?;
                        match self.handle_generator_info(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Catalog(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"CATALOG",
                            false,
                        )?;
                        match self.handle_catalog(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Buyer(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"BUYER",
                            false,
                        )?;
                        match self.handle_buyer(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Supplier(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"SUPPLIER",
                            false,
                        )?;
                        match self.handle_supplier(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UserDefinedExtensions(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"USER_DEFINED_EXTENSIONS",
                            false,
                        )?;
                        match self.handle_user_defined_extensions(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::HeaderElementType, Error> {
            let state = replace(
                &mut *self.state__,
                HeaderElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::HeaderElementType {
                generator_info: self.generator_info,
                catalog: helper.finish_element("CATALOG", self.catalog)?,
                buyer: helper.finish_element("BUYER", self.buyer)?,
                supplier: helper.finish_element("SUPPLIER", self.supplier)?,
                user_defined_extensions: helper
                    .finish_element("USER_DEFINED_EXTENSIONS", self.user_defined_extensions)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct TNewCatalogElementTypeDeserializer {
        product: Vec<super::TNewCatalogProductElementType>,
        state__: Box<TNewCatalogElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum TNewCatalogElementTypeDeserializerState {
        Init__,
        Product(Option<<super::TNewCatalogProductElementType as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl TNewCatalogElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                product: Vec::new(),
                state__: Box::new(TNewCatalogElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: TNewCatalogElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use TNewCatalogElementTypeDeserializerState as S;
            match state {
                S::Product(Some(deserializer)) => {
                    self.store_product(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_product(
            &mut self,
            value: super::TNewCatalogProductElementType,
        ) -> Result<(), Error> {
            self.product.push(value);
            Ok(())
        }
        fn handle_product<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::TNewCatalogProductElementType>,
            fallback: &mut Option<TNewCatalogElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TNewCatalogElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.product.len() < 1usize {
                    fallback.get_or_insert(S::Product(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product(data)?;
                    *self.state__ = S::Product(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Product(Some(deserializer)));
                    *self.state__ = S::Product(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::TNewCatalogElementType> for TNewCatalogElementTypeDeserializer {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::TNewCatalogElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::TNewCatalogElementType> {
            use TNewCatalogElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::Product(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::Product(None);
                        event
                    }
                    (S::Product(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT",
                            false,
                        )?;
                        match self.handle_product(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::TNewCatalogElementType, Error> {
            let state = replace(
                &mut *self.state__,
                TNewCatalogElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::TNewCatalogElementType {
                product: helper.finish_vec(1usize, None, self.product)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct TUpdateProductsElementTypeDeserializer {
        prev_version: i32,
        product: Vec<super::TUpdateProductsProductElementType>,
        state__: Box<TUpdateProductsElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum TUpdateProductsElementTypeDeserializerState {
        Init__,
        Product(
            Option<<super::TUpdateProductsProductElementType as WithDeserializer>::Deserializer>,
        ),
        Done__,
        Unknown__,
    }
    impl TUpdateProductsElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut prev_version: Option<i32> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"prev_version")
                ) {
                    helper.read_attrib(&mut prev_version, b"prev_version", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                prev_version: prev_version
                    .ok_or_else(|| ErrorKind::MissingAttribute("prev_version".into()))?,
                product: Vec::new(),
                state__: Box::new(TUpdateProductsElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: TUpdateProductsElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use TUpdateProductsElementTypeDeserializerState as S;
            match state {
                S::Product(Some(deserializer)) => {
                    self.store_product(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_product(
            &mut self,
            value: super::TUpdateProductsProductElementType,
        ) -> Result<(), Error> {
            self.product.push(value);
            Ok(())
        }
        fn handle_product<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::TUpdateProductsProductElementType>,
            fallback: &mut Option<TUpdateProductsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TUpdateProductsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.product.len() < 1usize {
                    fallback.get_or_insert(S::Product(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product(data)?;
                    *self.state__ = S::Product(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Product(Some(deserializer)));
                    *self.state__ = S::Product(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::TUpdateProductsElementType>
        for TUpdateProductsElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::TUpdateProductsElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::TUpdateProductsElementType> {
            use TUpdateProductsElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::Product(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::Product(None);
                        event
                    }
                    (S::Product(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT",
                            false,
                        )?;
                        match self.handle_product(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::TUpdateProductsElementType, Error> {
            let state = replace(
                &mut *self.state__,
                TUpdateProductsElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::TUpdateProductsElementType {
                prev_version: self.prev_version,
                product: helper.finish_vec(1usize, None, self.product)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct TUpdatePricesElementTypeDeserializer {
        prev_version: i32,
        product: Vec<super::TUpdatePricesProductElementType>,
        state__: Box<TUpdatePricesElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum TUpdatePricesElementTypeDeserializerState {
        Init__,
        Product(Option<<super::TUpdatePricesProductElementType as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl TUpdatePricesElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut prev_version: Option<i32> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"prev_version")
                ) {
                    helper.read_attrib(&mut prev_version, b"prev_version", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                prev_version: prev_version
                    .ok_or_else(|| ErrorKind::MissingAttribute("prev_version".into()))?,
                product: Vec::new(),
                state__: Box::new(TUpdatePricesElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: TUpdatePricesElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use TUpdatePricesElementTypeDeserializerState as S;
            match state {
                S::Product(Some(deserializer)) => {
                    self.store_product(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_product(
            &mut self,
            value: super::TUpdatePricesProductElementType,
        ) -> Result<(), Error> {
            self.product.push(value);
            Ok(())
        }
        fn handle_product<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::TUpdatePricesProductElementType>,
            fallback: &mut Option<TUpdatePricesElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TUpdatePricesElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.product.len() < 1usize {
                    fallback.get_or_insert(S::Product(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product(data)?;
                    *self.state__ = S::Product(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Product(Some(deserializer)));
                    *self.state__ = S::Product(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::TUpdatePricesElementType>
        for TUpdatePricesElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::TUpdatePricesElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::TUpdatePricesElementType> {
            use TUpdatePricesElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::Product(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::Product(None);
                        event
                    }
                    (S::Product(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT",
                            false,
                        )?;
                        match self.handle_product(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::TUpdatePricesElementType, Error> {
            let state = replace(
                &mut *self.state__,
                TUpdatePricesElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::TUpdatePricesElementType {
                prev_version: self.prev_version,
                product: helper.finish_vec(1usize, None, self.product)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct CatalogElementTypeDeserializer {
        language: Vec<super::LanguageElementType>,
        catalog_id: Option<String>,
        catalog_version: Option<String>,
        catalog_name: Vec<super::DtMlstring>,
        datetime: Option<super::CatalogDatetimeElementType>,
        territory: Vec<String>,
        currency: Option<super::DtCurrencies>,
        mime_root: Vec<super::DtMlstring>,
        state__: Box<CatalogElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum CatalogElementTypeDeserializerState {
        Init__,
        Language(Option<<super::LanguageElementType as WithDeserializer>::Deserializer>),
        CatalogId(Option<<String as WithDeserializer>::Deserializer>),
        CatalogVersion(Option<<String as WithDeserializer>::Deserializer>),
        CatalogName(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        Datetime(Option<<super::CatalogDatetimeElementType as WithDeserializer>::Deserializer>),
        Territory(Option<<String as WithDeserializer>::Deserializer>),
        Currency(Option<<super::DtCurrencies as WithDeserializer>::Deserializer>),
        MimeRoot(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl CatalogElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                language: Vec::new(),
                catalog_id: None,
                catalog_version: None,
                catalog_name: Vec::new(),
                datetime: None,
                territory: Vec::new(),
                currency: None,
                mime_root: Vec::new(),
                state__: Box::new(CatalogElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: CatalogElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use CatalogElementTypeDeserializerState as S;
            match state {
                S::Language(Some(deserializer)) => {
                    self.store_language(deserializer.finish(helper)?)?
                }
                S::CatalogId(Some(deserializer)) => {
                    self.store_catalog_id(deserializer.finish(helper)?)?
                }
                S::CatalogVersion(Some(deserializer)) => {
                    self.store_catalog_version(deserializer.finish(helper)?)?
                }
                S::CatalogName(Some(deserializer)) => {
                    self.store_catalog_name(deserializer.finish(helper)?)?
                }
                S::Datetime(Some(deserializer)) => {
                    self.store_datetime(deserializer.finish(helper)?)?
                }
                S::Territory(Some(deserializer)) => {
                    self.store_territory(deserializer.finish(helper)?)?
                }
                S::Currency(Some(deserializer)) => {
                    self.store_currency(deserializer.finish(helper)?)?
                }
                S::MimeRoot(Some(deserializer)) => {
                    self.store_mime_root(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_language(&mut self, value: super::LanguageElementType) -> Result<(), Error> {
            self.language.push(value);
            Ok(())
        }
        fn store_catalog_id(&mut self, value: String) -> Result<(), Error> {
            if self.catalog_id.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"CATALOG_ID",
                )))?;
            }
            self.catalog_id = Some(value);
            Ok(())
        }
        fn store_catalog_version(&mut self, value: String) -> Result<(), Error> {
            if self.catalog_version.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"CATALOG_VERSION",
                )))?;
            }
            self.catalog_version = Some(value);
            Ok(())
        }
        fn store_catalog_name(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.catalog_name.push(value);
            Ok(())
        }
        fn store_datetime(
            &mut self,
            value: super::CatalogDatetimeElementType,
        ) -> Result<(), Error> {
            if self.datetime.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"DATETIME",
                )))?;
            }
            self.datetime = Some(value);
            Ok(())
        }
        fn store_territory(&mut self, value: String) -> Result<(), Error> {
            self.territory.push(value);
            Ok(())
        }
        fn store_currency(&mut self, value: super::DtCurrencies) -> Result<(), Error> {
            if self.currency.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"CURRENCY",
                )))?;
            }
            self.currency = Some(value);
            Ok(())
        }
        fn store_mime_root(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.mime_root.push(value);
            Ok(())
        }
        fn handle_language<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::LanguageElementType>,
            fallback: &mut Option<CatalogElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use CatalogElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.language.len() < 1usize {
                    fallback.get_or_insert(S::Language(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::CatalogId(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_language(data)?;
                    *self.state__ = S::Language(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Language(Some(deserializer)));
                    *self.state__ = S::Language(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_catalog_id<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<CatalogElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use CatalogElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::CatalogId(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_catalog_id(data)?;
                    *self.state__ = S::CatalogVersion(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::CatalogId(Some(deserializer)));
                    *self.state__ = S::CatalogVersion(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_catalog_version<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<CatalogElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use CatalogElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::CatalogVersion(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_catalog_version(data)?;
                    *self.state__ = S::CatalogName(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::CatalogVersion(Some(deserializer)));
                    *self.state__ = S::CatalogName(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_catalog_name<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<CatalogElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use CatalogElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.catalog_name.len() < 1usize {
                    fallback.get_or_insert(S::CatalogName(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::Datetime(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_catalog_name(data)?;
                    *self.state__ = S::CatalogName(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::CatalogName(Some(deserializer)));
                    *self.state__ = S::CatalogName(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_datetime<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::CatalogDatetimeElementType>,
            fallback: &mut Option<CatalogElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use CatalogElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::Datetime(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_datetime(data)?;
                    *self.state__ = S::Territory(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Datetime(Some(deserializer)));
                    *self.state__ = S::Territory(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_territory<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<CatalogElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use CatalogElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Currency(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_territory(data)?;
                    *self.state__ = S::Territory(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Territory(Some(deserializer)));
                    *self.state__ = S::Territory(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_currency<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtCurrencies>,
            fallback: &mut Option<CatalogElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use CatalogElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::MimeRoot(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_currency(data)?;
                    *self.state__ = S::MimeRoot(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Currency(Some(deserializer)));
                    *self.state__ = S::MimeRoot(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_mime_root<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<CatalogElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use CatalogElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Done__;
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_mime_root(data)?;
                    *self.state__ = S::MimeRoot(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::MimeRoot(Some(deserializer)));
                    *self.state__ = S::MimeRoot(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::CatalogElementType> for CatalogElementTypeDeserializer {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::CatalogElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::CatalogElementType> {
            use CatalogElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::Language(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_language(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::CatalogId(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_catalog_id(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::CatalogVersion(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_catalog_version(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::CatalogName(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_catalog_name(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Datetime(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_datetime(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Territory(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_territory(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Currency(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_currency(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::MimeRoot(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_mime_root(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::Language(None);
                        event
                    }
                    (S::Language(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"LANGUAGE",
                            false,
                        )?;
                        match self.handle_language(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::CatalogId(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"CATALOG_ID",
                            false,
                        )?;
                        match self.handle_catalog_id(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::CatalogVersion(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"CATALOG_VERSION",
                            false,
                        )?;
                        match self.handle_catalog_version(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::CatalogName(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"CATALOG_NAME",
                            false,
                        )?;
                        match self.handle_catalog_name(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Datetime(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"DATETIME",
                            false,
                        )?;
                        match self.handle_datetime(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Territory(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"TERRITORY",
                            false,
                        )?;
                        match self.handle_territory(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Currency(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"CURRENCY",
                            false,
                        )?;
                        match self.handle_currency(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::MimeRoot(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"MIME_ROOT",
                            false,
                        )?;
                        match self.handle_mime_root(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::CatalogElementType, Error> {
            let state = replace(
                &mut *self.state__,
                CatalogElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::CatalogElementType {
                language: helper.finish_vec(1usize, None, self.language)?,
                catalog_id: helper.finish_element("CATALOG_ID", self.catalog_id)?,
                catalog_version: helper.finish_element("CATALOG_VERSION", self.catalog_version)?,
                catalog_name: helper.finish_vec(1usize, None, self.catalog_name)?,
                datetime: helper.finish_element("DATETIME", self.datetime)?,
                territory: self.territory,
                currency: self.currency,
                mime_root: self.mime_root,
            })
        }
    }
    #[derive(Debug)]
    pub struct BuyerElementTypeDeserializer {
        buyer_id: Option<super::TypePartyId>,
        buyer_name: Option<String>,
        state__: Box<BuyerElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum BuyerElementTypeDeserializerState {
        Init__,
        BuyerId(Option<<super::TypePartyId as WithDeserializer>::Deserializer>),
        BuyerName(Option<<String as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl BuyerElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                buyer_id: None,
                buyer_name: None,
                state__: Box::new(BuyerElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: BuyerElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use BuyerElementTypeDeserializerState as S;
            match state {
                S::BuyerId(Some(deserializer)) => {
                    self.store_buyer_id(deserializer.finish(helper)?)?
                }
                S::BuyerName(Some(deserializer)) => {
                    self.store_buyer_name(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_buyer_id(&mut self, value: super::TypePartyId) -> Result<(), Error> {
            if self.buyer_id.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"BUYER_ID",
                )))?;
            }
            self.buyer_id = Some(value);
            Ok(())
        }
        fn store_buyer_name(&mut self, value: String) -> Result<(), Error> {
            if self.buyer_name.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"BUYER_NAME",
                )))?;
            }
            self.buyer_name = Some(value);
            Ok(())
        }
        fn handle_buyer_id<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::TypePartyId>,
            fallback: &mut Option<BuyerElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use BuyerElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::BuyerName(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_buyer_id(data)?;
                    *self.state__ = S::BuyerName(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::BuyerId(Some(deserializer)));
                    *self.state__ = S::BuyerName(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_buyer_name<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<BuyerElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use BuyerElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::BuyerName(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_buyer_name(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::BuyerName(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::BuyerElementType> for BuyerElementTypeDeserializer {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::BuyerElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::BuyerElementType> {
            use BuyerElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::BuyerId(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_buyer_id(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::BuyerName(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_buyer_name(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::BuyerId(None);
                        event
                    }
                    (S::BuyerId(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"BUYER_ID",
                            false,
                        )?;
                        match self.handle_buyer_id(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::BuyerName(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"BUYER_NAME",
                            false,
                        )?;
                        match self.handle_buyer_name(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::BuyerElementType, Error> {
            let state = replace(
                &mut *self.state__,
                BuyerElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::BuyerElementType {
                buyer_id: self.buyer_id,
                buyer_name: helper.finish_element("BUYER_NAME", self.buyer_name)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct SupplierElementTypeDeserializer {
        supplier_id: Vec<super::TypePartyId>,
        supplier_name: Option<String>,
        address: Option<super::SupplierAddressElementType>,
        mime_info: Option<super::MimeInfoElementType>,
        state__: Box<SupplierElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum SupplierElementTypeDeserializerState {
        Init__,
        SupplierId(Option<<super::TypePartyId as WithDeserializer>::Deserializer>),
        SupplierName(Option<<String as WithDeserializer>::Deserializer>),
        Address(Option<<super::SupplierAddressElementType as WithDeserializer>::Deserializer>),
        MimeInfo(Option<<super::MimeInfoElementType as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl SupplierElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                supplier_id: Vec::new(),
                supplier_name: None,
                address: None,
                mime_info: None,
                state__: Box::new(SupplierElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: SupplierElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use SupplierElementTypeDeserializerState as S;
            match state {
                S::SupplierId(Some(deserializer)) => {
                    self.store_supplier_id(deserializer.finish(helper)?)?
                }
                S::SupplierName(Some(deserializer)) => {
                    self.store_supplier_name(deserializer.finish(helper)?)?
                }
                S::Address(Some(deserializer)) => {
                    self.store_address(deserializer.finish(helper)?)?
                }
                S::MimeInfo(Some(deserializer)) => {
                    self.store_mime_info(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_supplier_id(&mut self, value: super::TypePartyId) -> Result<(), Error> {
            self.supplier_id.push(value);
            Ok(())
        }
        fn store_supplier_name(&mut self, value: String) -> Result<(), Error> {
            if self.supplier_name.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"SUPPLIER_NAME",
                )))?;
            }
            self.supplier_name = Some(value);
            Ok(())
        }
        fn store_address(&mut self, value: super::SupplierAddressElementType) -> Result<(), Error> {
            if self.address.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"ADDRESS",
                )))?;
            }
            self.address = Some(value);
            Ok(())
        }
        fn store_mime_info(&mut self, value: super::MimeInfoElementType) -> Result<(), Error> {
            if self.mime_info.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"MIME_INFO",
                )))?;
            }
            self.mime_info = Some(value);
            Ok(())
        }
        fn handle_supplier_id<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::TypePartyId>,
            fallback: &mut Option<SupplierElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use SupplierElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::SupplierName(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_supplier_id(data)?;
                    if self.supplier_id.len() < 2usize {
                        *self.state__ = S::SupplierId(None);
                    } else {
                        *self.state__ = S::SupplierName(None);
                    }
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::SupplierId(Some(deserializer)));
                    if self.supplier_id.len() < 1usize {
                        *self.state__ = S::SupplierId(None);
                    } else {
                        *self.state__ = S::SupplierName(None);
                    }
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_supplier_name<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<SupplierElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use SupplierElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::SupplierName(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_supplier_name(data)?;
                    *self.state__ = S::Address(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::SupplierName(Some(deserializer)));
                    *self.state__ = S::Address(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_address<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::SupplierAddressElementType>,
            fallback: &mut Option<SupplierElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use SupplierElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::MimeInfo(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_address(data)?;
                    *self.state__ = S::MimeInfo(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Address(Some(deserializer)));
                    *self.state__ = S::MimeInfo(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_mime_info<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::MimeInfoElementType>,
            fallback: &mut Option<SupplierElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use SupplierElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Done__;
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_mime_info(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::MimeInfo(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::SupplierElementType> for SupplierElementTypeDeserializer {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::SupplierElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::SupplierElementType> {
            use SupplierElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::SupplierId(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_supplier_id(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::SupplierName(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_supplier_name(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Address(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_address(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::MimeInfo(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_mime_info(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::SupplierId(None);
                        event
                    }
                    (S::SupplierId(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"SUPPLIER_ID",
                            false,
                        )?;
                        match self.handle_supplier_id(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::SupplierName(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"SUPPLIER_NAME",
                            false,
                        )?;
                        match self.handle_supplier_name(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Address(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"ADDRESS",
                            false,
                        )?;
                        match self.handle_address(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::MimeInfo(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"MIME_INFO",
                            false,
                        )?;
                        match self.handle_mime_info(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::SupplierElementType, Error> {
            let state = replace(
                &mut *self.state__,
                SupplierElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::SupplierElementType {
                supplier_id: self.supplier_id,
                supplier_name: helper.finish_element("SUPPLIER_NAME", self.supplier_name)?,
                address: self.address,
                mime_info: self.mime_info,
            })
        }
    }
    #[derive(Debug)]
    pub struct UdxHeaderDeserializer {
        udx_edxf_version: Option<String>,
        state__: Box<UdxHeaderDeserializerState>,
    }
    #[derive(Debug)]
    enum UdxHeaderDeserializerState {
        Init__,
        UdxEdxfVersion(Option<<String as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl UdxHeaderDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                udx_edxf_version: None,
                state__: Box::new(UdxHeaderDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: UdxHeaderDeserializerState,
        ) -> Result<(), Error> {
            use UdxHeaderDeserializerState as S;
            match state {
                S::UdxEdxfVersion(Some(deserializer)) => {
                    self.store_udx_edxf_version(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_udx_edxf_version(&mut self, value: String) -> Result<(), Error> {
            if self.udx_edxf_version.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.VERSION",
                )))?;
            }
            self.udx_edxf_version = Some(value);
            Ok(())
        }
        fn handle_udx_edxf_version<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<UdxHeaderDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxHeaderDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::UdxEdxfVersion(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_version(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfVersion(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::UdxHeader> for UdxHeaderDeserializer {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxHeader> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxHeader> {
            use UdxHeaderDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::UdxEdxfVersion(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_version(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::UdxEdxfVersion(None);
                        event
                    }
                    (S::UdxEdxfVersion(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.VERSION",
                            false,
                        )?;
                        match self.handle_udx_edxf_version(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(mut self, helper: &mut DeserializeHelper) -> Result<super::UdxHeader, Error> {
            let state = replace(&mut *self.state__, UdxHeaderDeserializerState::Unknown__);
            self.finish_state(helper, state)?;
            Ok(super::UdxHeader {
                udx_edxf_version: helper
                    .finish_element("UDX.EDXF.VERSION", self.udx_edxf_version)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct TNewCatalogProductElementTypeDeserializer {
        mode: super::TNewCatalogProductMode,
        supplier_pid: Option<super::SupplierPidElementType>,
        product_details: Option<super::ProductDetailsElementType>,
        product_features: Vec<super::ProductFeaturesElementType>,
        product_order_details: Option<super::ProductOrderDetailsElementType>,
        product_price_details: Vec<super::ProductPriceDetailsElementType>,
        mime_info: Option<super::MimeInfoElementType>,
        user_defined_extensions: Option<super::UdxProduct>,
        product_reference: Vec<super::ProductReferenceElementType>,
        product_logistic_details: Option<super::ProductLogisticDetailsElementType>,
        state__: Box<TNewCatalogProductElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum TNewCatalogProductElementTypeDeserializerState {
        Init__,
        SupplierPid(Option<<super::SupplierPidElementType as WithDeserializer>::Deserializer>),
        ProductDetails(
            Option<<super::ProductDetailsElementType as WithDeserializer>::Deserializer>,
        ),
        ProductFeatures(
            Option<<super::ProductFeaturesElementType as WithDeserializer>::Deserializer>,
        ),
        ProductOrderDetails(
            Option<<super::ProductOrderDetailsElementType as WithDeserializer>::Deserializer>,
        ),
        ProductPriceDetails(
            Option<<super::ProductPriceDetailsElementType as WithDeserializer>::Deserializer>,
        ),
        MimeInfo(Option<<super::MimeInfoElementType as WithDeserializer>::Deserializer>),
        UserDefinedExtensions(Option<<super::UdxProduct as WithDeserializer>::Deserializer>),
        ProductReference(
            Option<<super::ProductReferenceElementType as WithDeserializer>::Deserializer>,
        ),
        ProductLogisticDetails(
            Option<<super::ProductLogisticDetailsElementType as WithDeserializer>::Deserializer>,
        ),
        Done__,
        Unknown__,
    }
    impl TNewCatalogProductElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut mode: Option<super::TNewCatalogProductMode> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"mode")
                ) {
                    helper.read_attrib(&mut mode, b"mode", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                mode: mode.unwrap_or_else(super::TNewCatalogProductElementType::default_mode),
                supplier_pid: None,
                product_details: None,
                product_features: Vec::new(),
                product_order_details: None,
                product_price_details: Vec::new(),
                mime_info: None,
                user_defined_extensions: None,
                product_reference: Vec::new(),
                product_logistic_details: None,
                state__: Box::new(TNewCatalogProductElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: TNewCatalogProductElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use TNewCatalogProductElementTypeDeserializerState as S;
            match state {
                S::SupplierPid(Some(deserializer)) => {
                    self.store_supplier_pid(deserializer.finish(helper)?)?
                }
                S::ProductDetails(Some(deserializer)) => {
                    self.store_product_details(deserializer.finish(helper)?)?
                }
                S::ProductFeatures(Some(deserializer)) => {
                    self.store_product_features(deserializer.finish(helper)?)?
                }
                S::ProductOrderDetails(Some(deserializer)) => {
                    self.store_product_order_details(deserializer.finish(helper)?)?
                }
                S::ProductPriceDetails(Some(deserializer)) => {
                    self.store_product_price_details(deserializer.finish(helper)?)?
                }
                S::MimeInfo(Some(deserializer)) => {
                    self.store_mime_info(deserializer.finish(helper)?)?
                }
                S::UserDefinedExtensions(Some(deserializer)) => {
                    self.store_user_defined_extensions(deserializer.finish(helper)?)?
                }
                S::ProductReference(Some(deserializer)) => {
                    self.store_product_reference(deserializer.finish(helper)?)?
                }
                S::ProductLogisticDetails(Some(deserializer)) => {
                    self.store_product_logistic_details(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_supplier_pid(
            &mut self,
            value: super::SupplierPidElementType,
        ) -> Result<(), Error> {
            if self.supplier_pid.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"SUPPLIER_PID",
                )))?;
            }
            self.supplier_pid = Some(value);
            Ok(())
        }
        fn store_product_details(
            &mut self,
            value: super::ProductDetailsElementType,
        ) -> Result<(), Error> {
            if self.product_details.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"PRODUCT_DETAILS",
                )))?;
            }
            self.product_details = Some(value);
            Ok(())
        }
        fn store_product_features(
            &mut self,
            value: super::ProductFeaturesElementType,
        ) -> Result<(), Error> {
            self.product_features.push(value);
            Ok(())
        }
        fn store_product_order_details(
            &mut self,
            value: super::ProductOrderDetailsElementType,
        ) -> Result<(), Error> {
            if self.product_order_details.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"PRODUCT_ORDER_DETAILS",
                )))?;
            }
            self.product_order_details = Some(value);
            Ok(())
        }
        fn store_product_price_details(
            &mut self,
            value: super::ProductPriceDetailsElementType,
        ) -> Result<(), Error> {
            self.product_price_details.push(value);
            Ok(())
        }
        fn store_mime_info(&mut self, value: super::MimeInfoElementType) -> Result<(), Error> {
            if self.mime_info.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"MIME_INFO",
                )))?;
            }
            self.mime_info = Some(value);
            Ok(())
        }
        fn store_user_defined_extensions(&mut self, value: super::UdxProduct) -> Result<(), Error> {
            if self.user_defined_extensions.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"USER_DEFINED_EXTENSIONS",
                )))?;
            }
            self.user_defined_extensions = Some(value);
            Ok(())
        }
        fn store_product_reference(
            &mut self,
            value: super::ProductReferenceElementType,
        ) -> Result<(), Error> {
            self.product_reference.push(value);
            Ok(())
        }
        fn store_product_logistic_details(
            &mut self,
            value: super::ProductLogisticDetailsElementType,
        ) -> Result<(), Error> {
            if self.product_logistic_details.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"PRODUCT_LOGISTIC_DETAILS",
                )))?;
            }
            self.product_logistic_details = Some(value);
            Ok(())
        }
        fn handle_supplier_pid<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::SupplierPidElementType>,
            fallback: &mut Option<TNewCatalogProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TNewCatalogProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::SupplierPid(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_supplier_pid(data)?;
                    *self.state__ = S::ProductDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::SupplierPid(Some(deserializer)));
                    *self.state__ = S::ProductDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_product_details<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::ProductDetailsElementType>,
            fallback: &mut Option<TNewCatalogProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TNewCatalogProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::ProductDetails(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product_details(data)?;
                    *self.state__ = S::ProductFeatures(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ProductDetails(Some(deserializer)));
                    *self.state__ = S::ProductFeatures(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_product_features<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::ProductFeaturesElementType>,
            fallback: &mut Option<TNewCatalogProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TNewCatalogProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.product_features.len() < 1usize {
                    fallback.get_or_insert(S::ProductFeatures(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::ProductOrderDetails(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product_features(data)?;
                    *self.state__ = S::ProductFeatures(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ProductFeatures(Some(deserializer)));
                    *self.state__ = S::ProductFeatures(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_product_order_details<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::ProductOrderDetailsElementType>,
            fallback: &mut Option<TNewCatalogProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TNewCatalogProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::ProductOrderDetails(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product_order_details(data)?;
                    *self.state__ = S::ProductPriceDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ProductOrderDetails(Some(deserializer)));
                    *self.state__ = S::ProductPriceDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_product_price_details<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::ProductPriceDetailsElementType>,
            fallback: &mut Option<TNewCatalogProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TNewCatalogProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.product_price_details.len() < 1usize {
                    fallback.get_or_insert(S::ProductPriceDetails(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::MimeInfo(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product_price_details(data)?;
                    *self.state__ = S::ProductPriceDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ProductPriceDetails(Some(deserializer)));
                    *self.state__ = S::ProductPriceDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_mime_info<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::MimeInfoElementType>,
            fallback: &mut Option<TNewCatalogProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TNewCatalogProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UserDefinedExtensions(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_mime_info(data)?;
                    *self.state__ = S::UserDefinedExtensions(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::MimeInfo(Some(deserializer)));
                    *self.state__ = S::UserDefinedExtensions(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_user_defined_extensions<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::UdxProduct>,
            fallback: &mut Option<TNewCatalogProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TNewCatalogProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::UserDefinedExtensions(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_user_defined_extensions(data)?;
                    *self.state__ = S::ProductReference(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UserDefinedExtensions(Some(deserializer)));
                    *self.state__ = S::ProductReference(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_product_reference<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::ProductReferenceElementType>,
            fallback: &mut Option<TNewCatalogProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TNewCatalogProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::ProductLogisticDetails(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product_reference(data)?;
                    *self.state__ = S::ProductReference(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ProductReference(Some(deserializer)));
                    *self.state__ = S::ProductReference(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_product_logistic_details<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::ProductLogisticDetailsElementType>,
            fallback: &mut Option<TNewCatalogProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TNewCatalogProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Done__;
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product_logistic_details(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ProductLogisticDetails(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::TNewCatalogProductElementType>
        for TNewCatalogProductElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::TNewCatalogProductElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::TNewCatalogProductElementType> {
            use TNewCatalogProductElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::SupplierPid(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_supplier_pid(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductDetails(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product_details(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductFeatures(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product_features(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductOrderDetails(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product_order_details(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductPriceDetails(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product_price_details(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::MimeInfo(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_mime_info(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UserDefinedExtensions(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_user_defined_extensions(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductReference(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product_reference(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductLogisticDetails(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product_logistic_details(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::SupplierPid(None);
                        event
                    }
                    (S::SupplierPid(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"SUPPLIER_PID",
                            false,
                        )?;
                        match self.handle_supplier_pid(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductDetails(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT_DETAILS",
                            false,
                        )?;
                        match self.handle_product_details(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductFeatures(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT_FEATURES",
                            false,
                        )?;
                        match self.handle_product_features(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductOrderDetails(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT_ORDER_DETAILS",
                            false,
                        )?;
                        match self.handle_product_order_details(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductPriceDetails(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT_PRICE_DETAILS",
                            false,
                        )?;
                        match self.handle_product_price_details(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::MimeInfo(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"MIME_INFO",
                            false,
                        )?;
                        match self.handle_mime_info(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UserDefinedExtensions(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"USER_DEFINED_EXTENSIONS",
                            false,
                        )?;
                        match self.handle_user_defined_extensions(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductReference(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT_REFERENCE",
                            false,
                        )?;
                        match self.handle_product_reference(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::ProductLogisticDetails(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT_LOGISTIC_DETAILS",
                            false,
                        )?;
                        match self.handle_product_logistic_details(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::TNewCatalogProductElementType, Error> {
            let state = replace(
                &mut *self.state__,
                TNewCatalogProductElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::TNewCatalogProductElementType {
                mode: self.mode,
                supplier_pid: helper.finish_element("SUPPLIER_PID", self.supplier_pid)?,
                product_details: helper.finish_element("PRODUCT_DETAILS", self.product_details)?,
                product_features: helper.finish_vec(1usize, None, self.product_features)?,
                product_order_details: helper
                    .finish_element("PRODUCT_ORDER_DETAILS", self.product_order_details)?,
                product_price_details: helper.finish_vec(
                    1usize,
                    None,
                    self.product_price_details,
                )?,
                mime_info: self.mime_info,
                user_defined_extensions: helper
                    .finish_element("USER_DEFINED_EXTENSIONS", self.user_defined_extensions)?,
                product_reference: self.product_reference,
                product_logistic_details: self.product_logistic_details,
            })
        }
    }
    #[derive(Debug)]
    pub struct TUpdateProductsProductElementTypeDeserializer {
        mode: super::TUpdateProductsProductMode,
        supplier_pid: Option<super::SupplierPidElementType>,
        product_details: Option<super::ProductDetailsElementType>,
        product_features: Vec<super::ProductFeaturesElementType>,
        product_order_details: Option<super::ProductOrderDetailsElementType>,
        product_price_details: Vec<super::ProductPriceDetailsElementType>,
        mime_info: Option<super::MimeInfoElementType>,
        user_defined_extensions: Option<super::UdxProduct>,
        product_reference: Vec<super::ProductReferenceElementType>,
        product_logistic_details: Option<super::ProductLogisticDetailsElementType>,
        state__: Box<TUpdateProductsProductElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum TUpdateProductsProductElementTypeDeserializerState {
        Init__,
        SupplierPid(Option<<super::SupplierPidElementType as WithDeserializer>::Deserializer>),
        ProductDetails(
            Option<<super::ProductDetailsElementType as WithDeserializer>::Deserializer>,
        ),
        ProductFeatures(
            Option<<super::ProductFeaturesElementType as WithDeserializer>::Deserializer>,
        ),
        ProductOrderDetails(
            Option<<super::ProductOrderDetailsElementType as WithDeserializer>::Deserializer>,
        ),
        ProductPriceDetails(
            Option<<super::ProductPriceDetailsElementType as WithDeserializer>::Deserializer>,
        ),
        MimeInfo(Option<<super::MimeInfoElementType as WithDeserializer>::Deserializer>),
        UserDefinedExtensions(Option<<super::UdxProduct as WithDeserializer>::Deserializer>),
        ProductReference(
            Option<<super::ProductReferenceElementType as WithDeserializer>::Deserializer>,
        ),
        ProductLogisticDetails(
            Option<<super::ProductLogisticDetailsElementType as WithDeserializer>::Deserializer>,
        ),
        Done__,
        Unknown__,
    }
    impl TUpdateProductsProductElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut mode: Option<super::TUpdateProductsProductMode> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"mode")
                ) {
                    helper.read_attrib(&mut mode, b"mode", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                mode: mode.ok_or_else(|| ErrorKind::MissingAttribute("mode".into()))?,
                supplier_pid: None,
                product_details: None,
                product_features: Vec::new(),
                product_order_details: None,
                product_price_details: Vec::new(),
                mime_info: None,
                user_defined_extensions: None,
                product_reference: Vec::new(),
                product_logistic_details: None,
                state__: Box::new(TUpdateProductsProductElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: TUpdateProductsProductElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use TUpdateProductsProductElementTypeDeserializerState as S;
            match state {
                S::SupplierPid(Some(deserializer)) => {
                    self.store_supplier_pid(deserializer.finish(helper)?)?
                }
                S::ProductDetails(Some(deserializer)) => {
                    self.store_product_details(deserializer.finish(helper)?)?
                }
                S::ProductFeatures(Some(deserializer)) => {
                    self.store_product_features(deserializer.finish(helper)?)?
                }
                S::ProductOrderDetails(Some(deserializer)) => {
                    self.store_product_order_details(deserializer.finish(helper)?)?
                }
                S::ProductPriceDetails(Some(deserializer)) => {
                    self.store_product_price_details(deserializer.finish(helper)?)?
                }
                S::MimeInfo(Some(deserializer)) => {
                    self.store_mime_info(deserializer.finish(helper)?)?
                }
                S::UserDefinedExtensions(Some(deserializer)) => {
                    self.store_user_defined_extensions(deserializer.finish(helper)?)?
                }
                S::ProductReference(Some(deserializer)) => {
                    self.store_product_reference(deserializer.finish(helper)?)?
                }
                S::ProductLogisticDetails(Some(deserializer)) => {
                    self.store_product_logistic_details(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_supplier_pid(
            &mut self,
            value: super::SupplierPidElementType,
        ) -> Result<(), Error> {
            if self.supplier_pid.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"SUPPLIER_PID",
                )))?;
            }
            self.supplier_pid = Some(value);
            Ok(())
        }
        fn store_product_details(
            &mut self,
            value: super::ProductDetailsElementType,
        ) -> Result<(), Error> {
            if self.product_details.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"PRODUCT_DETAILS",
                )))?;
            }
            self.product_details = Some(value);
            Ok(())
        }
        fn store_product_features(
            &mut self,
            value: super::ProductFeaturesElementType,
        ) -> Result<(), Error> {
            self.product_features.push(value);
            Ok(())
        }
        fn store_product_order_details(
            &mut self,
            value: super::ProductOrderDetailsElementType,
        ) -> Result<(), Error> {
            if self.product_order_details.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"PRODUCT_ORDER_DETAILS",
                )))?;
            }
            self.product_order_details = Some(value);
            Ok(())
        }
        fn store_product_price_details(
            &mut self,
            value: super::ProductPriceDetailsElementType,
        ) -> Result<(), Error> {
            self.product_price_details.push(value);
            Ok(())
        }
        fn store_mime_info(&mut self, value: super::MimeInfoElementType) -> Result<(), Error> {
            if self.mime_info.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"MIME_INFO",
                )))?;
            }
            self.mime_info = Some(value);
            Ok(())
        }
        fn store_user_defined_extensions(&mut self, value: super::UdxProduct) -> Result<(), Error> {
            if self.user_defined_extensions.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"USER_DEFINED_EXTENSIONS",
                )))?;
            }
            self.user_defined_extensions = Some(value);
            Ok(())
        }
        fn store_product_reference(
            &mut self,
            value: super::ProductReferenceElementType,
        ) -> Result<(), Error> {
            self.product_reference.push(value);
            Ok(())
        }
        fn store_product_logistic_details(
            &mut self,
            value: super::ProductLogisticDetailsElementType,
        ) -> Result<(), Error> {
            if self.product_logistic_details.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"PRODUCT_LOGISTIC_DETAILS",
                )))?;
            }
            self.product_logistic_details = Some(value);
            Ok(())
        }
        fn handle_supplier_pid<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::SupplierPidElementType>,
            fallback: &mut Option<TUpdateProductsProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TUpdateProductsProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::SupplierPid(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_supplier_pid(data)?;
                    *self.state__ = S::ProductDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::SupplierPid(Some(deserializer)));
                    *self.state__ = S::ProductDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_product_details<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::ProductDetailsElementType>,
            fallback: &mut Option<TUpdateProductsProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TUpdateProductsProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::ProductDetails(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product_details(data)?;
                    *self.state__ = S::ProductFeatures(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ProductDetails(Some(deserializer)));
                    *self.state__ = S::ProductFeatures(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_product_features<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::ProductFeaturesElementType>,
            fallback: &mut Option<TUpdateProductsProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TUpdateProductsProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::ProductOrderDetails(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product_features(data)?;
                    *self.state__ = S::ProductFeatures(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ProductFeatures(Some(deserializer)));
                    *self.state__ = S::ProductFeatures(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_product_order_details<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::ProductOrderDetailsElementType>,
            fallback: &mut Option<TUpdateProductsProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TUpdateProductsProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::ProductOrderDetails(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product_order_details(data)?;
                    *self.state__ = S::ProductPriceDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ProductOrderDetails(Some(deserializer)));
                    *self.state__ = S::ProductPriceDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_product_price_details<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::ProductPriceDetailsElementType>,
            fallback: &mut Option<TUpdateProductsProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TUpdateProductsProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.product_price_details.len() < 1usize {
                    fallback.get_or_insert(S::ProductPriceDetails(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::MimeInfo(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product_price_details(data)?;
                    *self.state__ = S::ProductPriceDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ProductPriceDetails(Some(deserializer)));
                    *self.state__ = S::ProductPriceDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_mime_info<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::MimeInfoElementType>,
            fallback: &mut Option<TUpdateProductsProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TUpdateProductsProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UserDefinedExtensions(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_mime_info(data)?;
                    *self.state__ = S::UserDefinedExtensions(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::MimeInfo(Some(deserializer)));
                    *self.state__ = S::UserDefinedExtensions(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_user_defined_extensions<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::UdxProduct>,
            fallback: &mut Option<TUpdateProductsProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TUpdateProductsProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::ProductReference(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_user_defined_extensions(data)?;
                    *self.state__ = S::ProductReference(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UserDefinedExtensions(Some(deserializer)));
                    *self.state__ = S::ProductReference(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_product_reference<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::ProductReferenceElementType>,
            fallback: &mut Option<TUpdateProductsProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TUpdateProductsProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::ProductLogisticDetails(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product_reference(data)?;
                    *self.state__ = S::ProductReference(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ProductReference(Some(deserializer)));
                    *self.state__ = S::ProductReference(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_product_logistic_details<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::ProductLogisticDetailsElementType>,
            fallback: &mut Option<TUpdateProductsProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TUpdateProductsProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Done__;
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product_logistic_details(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ProductLogisticDetails(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::TUpdateProductsProductElementType>
        for TUpdateProductsProductElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::TUpdateProductsProductElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::TUpdateProductsProductElementType> {
            use TUpdateProductsProductElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::SupplierPid(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_supplier_pid(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductDetails(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product_details(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductFeatures(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product_features(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductOrderDetails(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product_order_details(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductPriceDetails(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product_price_details(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::MimeInfo(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_mime_info(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UserDefinedExtensions(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_user_defined_extensions(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductReference(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product_reference(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductLogisticDetails(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product_logistic_details(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::SupplierPid(None);
                        event
                    }
                    (S::SupplierPid(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"SUPPLIER_PID",
                            false,
                        )?;
                        match self.handle_supplier_pid(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductDetails(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT_DETAILS",
                            false,
                        )?;
                        match self.handle_product_details(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductFeatures(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT_FEATURES",
                            false,
                        )?;
                        match self.handle_product_features(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductOrderDetails(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT_ORDER_DETAILS",
                            false,
                        )?;
                        match self.handle_product_order_details(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductPriceDetails(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT_PRICE_DETAILS",
                            false,
                        )?;
                        match self.handle_product_price_details(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::MimeInfo(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"MIME_INFO",
                            false,
                        )?;
                        match self.handle_mime_info(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UserDefinedExtensions(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"USER_DEFINED_EXTENSIONS",
                            false,
                        )?;
                        match self.handle_user_defined_extensions(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductReference(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT_REFERENCE",
                            false,
                        )?;
                        match self.handle_product_reference(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::ProductLogisticDetails(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT_LOGISTIC_DETAILS",
                            false,
                        )?;
                        match self.handle_product_logistic_details(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::TUpdateProductsProductElementType, Error> {
            let state = replace(
                &mut *self.state__,
                TUpdateProductsProductElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::TUpdateProductsProductElementType {
                mode: self.mode,
                supplier_pid: helper.finish_element("SUPPLIER_PID", self.supplier_pid)?,
                product_details: helper.finish_element("PRODUCT_DETAILS", self.product_details)?,
                product_features: self.product_features,
                product_order_details: helper
                    .finish_element("PRODUCT_ORDER_DETAILS", self.product_order_details)?,
                product_price_details: helper.finish_vec(
                    1usize,
                    None,
                    self.product_price_details,
                )?,
                mime_info: self.mime_info,
                user_defined_extensions: self.user_defined_extensions,
                product_reference: self.product_reference,
                product_logistic_details: self.product_logistic_details,
            })
        }
    }
    #[derive(Debug)]
    pub struct TUpdatePricesProductElementTypeDeserializer {
        mode: super::TUpdatePricesProductMode,
        supplier_pid: Option<super::SupplierPidElementType>,
        product_price_details: Vec<super::ProductPriceDetailsElementType>,
        user_defined_extensions: Option<super::UdxProduct>,
        state__: Box<TUpdatePricesProductElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum TUpdatePricesProductElementTypeDeserializerState {
        Init__,
        SupplierPid(Option<<super::SupplierPidElementType as WithDeserializer>::Deserializer>),
        ProductPriceDetails(
            Option<<super::ProductPriceDetailsElementType as WithDeserializer>::Deserializer>,
        ),
        UserDefinedExtensions(Option<<super::UdxProduct as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl TUpdatePricesProductElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut mode: Option<super::TUpdatePricesProductMode> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"mode")
                ) {
                    helper.read_attrib(&mut mode, b"mode", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                mode: mode.unwrap_or_else(super::TUpdatePricesProductElementType::default_mode),
                supplier_pid: None,
                product_price_details: Vec::new(),
                user_defined_extensions: None,
                state__: Box::new(TUpdatePricesProductElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: TUpdatePricesProductElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use TUpdatePricesProductElementTypeDeserializerState as S;
            match state {
                S::SupplierPid(Some(deserializer)) => {
                    self.store_supplier_pid(deserializer.finish(helper)?)?
                }
                S::ProductPriceDetails(Some(deserializer)) => {
                    self.store_product_price_details(deserializer.finish(helper)?)?
                }
                S::UserDefinedExtensions(Some(deserializer)) => {
                    self.store_user_defined_extensions(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_supplier_pid(
            &mut self,
            value: super::SupplierPidElementType,
        ) -> Result<(), Error> {
            if self.supplier_pid.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"SUPPLIER_PID",
                )))?;
            }
            self.supplier_pid = Some(value);
            Ok(())
        }
        fn store_product_price_details(
            &mut self,
            value: super::ProductPriceDetailsElementType,
        ) -> Result<(), Error> {
            self.product_price_details.push(value);
            Ok(())
        }
        fn store_user_defined_extensions(&mut self, value: super::UdxProduct) -> Result<(), Error> {
            if self.user_defined_extensions.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"USER_DEFINED_EXTENSIONS",
                )))?;
            }
            self.user_defined_extensions = Some(value);
            Ok(())
        }
        fn handle_supplier_pid<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::SupplierPidElementType>,
            fallback: &mut Option<TUpdatePricesProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TUpdatePricesProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::SupplierPid(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_supplier_pid(data)?;
                    *self.state__ = S::ProductPriceDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::SupplierPid(Some(deserializer)));
                    *self.state__ = S::ProductPriceDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_product_price_details<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::ProductPriceDetailsElementType>,
            fallback: &mut Option<TUpdatePricesProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TUpdatePricesProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.product_price_details.len() < 1usize {
                    fallback.get_or_insert(S::ProductPriceDetails(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::UserDefinedExtensions(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product_price_details(data)?;
                    *self.state__ = S::ProductPriceDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ProductPriceDetails(Some(deserializer)));
                    *self.state__ = S::ProductPriceDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_user_defined_extensions<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::UdxProduct>,
            fallback: &mut Option<TUpdatePricesProductElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use TUpdatePricesProductElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Done__;
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_user_defined_extensions(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UserDefinedExtensions(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::TUpdatePricesProductElementType>
        for TUpdatePricesProductElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::TUpdatePricesProductElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::TUpdatePricesProductElementType> {
            use TUpdatePricesProductElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::SupplierPid(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_supplier_pid(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductPriceDetails(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product_price_details(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UserDefinedExtensions(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_user_defined_extensions(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::SupplierPid(None);
                        event
                    }
                    (S::SupplierPid(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"SUPPLIER_PID",
                            false,
                        )?;
                        match self.handle_supplier_pid(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductPriceDetails(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT_PRICE_DETAILS",
                            false,
                        )?;
                        match self.handle_product_price_details(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UserDefinedExtensions(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"USER_DEFINED_EXTENSIONS",
                            false,
                        )?;
                        match self.handle_user_defined_extensions(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::TUpdatePricesProductElementType, Error> {
            let state = replace(
                &mut *self.state__,
                TUpdatePricesProductElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::TUpdatePricesProductElementType {
                mode: self.mode,
                supplier_pid: helper.finish_element("SUPPLIER_PID", self.supplier_pid)?,
                product_price_details: helper.finish_vec(
                    1usize,
                    None,
                    self.product_price_details,
                )?,
                user_defined_extensions: self.user_defined_extensions,
            })
        }
    }
    #[derive(Debug)]
    pub struct LanguageElementTypeDeserializer {
        default: Option<String>,
        content: Option<super::DtLang>,
        state__: Box<LanguageElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum LanguageElementTypeDeserializerState {
        Init__,
        Content__(<super::DtLang as WithDeserializer>::Deserializer),
        Unknown__,
    }
    impl LanguageElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut default: Option<String> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"default")
                ) {
                    helper.read_attrib(&mut default, b"default", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                default: default,
                content: None,
                state__: Box::new(LanguageElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: LanguageElementTypeDeserializerState,
        ) -> Result<(), Error> {
            if let LanguageElementTypeDeserializerState::Content__(deserializer) = state {
                self.store_content(deserializer.finish(helper)?)?;
            }
            Ok(())
        }
        fn store_content(&mut self, value: super::DtLang) -> Result<(), Error> {
            if self.content.is_some() {
                Err(ErrorKind::DuplicateContent)?;
            }
            self.content = Some(value);
            Ok(())
        }
        fn handle_content<'de>(
            mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtLang>,
        ) -> DeserializerResult<'de, super::LanguageElementType> {
            use LanguageElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            match artifact {
                DeserializerArtifact::None => Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event,
                    allow_any,
                }),
                DeserializerArtifact::Data(data) => {
                    self.store_content(data)?;
                    let data = self.finish(helper)?;
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(data),
                        event,
                        allow_any,
                    })
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::Content__(deserializer);
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event,
                        allow_any,
                    })
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::LanguageElementType> for LanguageElementTypeDeserializer {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::LanguageElementType> {
            let (Event::Start(x) | Event::Empty(x)) = &event else {
                return Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event: DeserializerEvent::Break(event),
                    allow_any: false,
                });
            };
            Self::from_bytes_start(helper, x)?.next(helper, event)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::LanguageElementType> {
            use LanguageElementTypeDeserializerState as S;
            match replace(&mut *self.state__, S::Unknown__) {
                S::Unknown__ => unreachable!(),
                S::Init__ => {
                    let output = ContentDeserializer::init(helper, event)?;
                    self.handle_content(helper, output)
                }
                S::Content__(deserializer) => {
                    let output = deserializer.next(helper, event)?;
                    self.handle_content(helper, output)
                }
            }
        }
        fn finish(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::LanguageElementType, Error> {
            let state = replace(
                &mut *self.state__,
                LanguageElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::LanguageElementType {
                default: self.default,
                content: helper.finish_content(self.content)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct DtMlstringDeserializer {
        lang: Option<super::DtLang>,
        content: Option<String>,
        state__: Box<DtMlstringDeserializerState>,
    }
    #[derive(Debug)]
    enum DtMlstringDeserializerState {
        Init__,
        Content__(<String as WithDeserializer>::Deserializer),
        Unknown__,
    }
    impl DtMlstringDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut lang: Option<super::DtLang> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"lang")
                ) {
                    helper.read_attrib(&mut lang, b"lang", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                lang: lang,
                content: None,
                state__: Box::new(DtMlstringDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: DtMlstringDeserializerState,
        ) -> Result<(), Error> {
            if let DtMlstringDeserializerState::Content__(deserializer) = state {
                self.store_content(deserializer.finish(helper)?)?;
            }
            Ok(())
        }
        fn store_content(&mut self, value: String) -> Result<(), Error> {
            if self.content.is_some() {
                Err(ErrorKind::DuplicateContent)?;
            }
            self.content = Some(value);
            Ok(())
        }
        fn handle_content<'de>(
            mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
        ) -> DeserializerResult<'de, super::DtMlstring> {
            use DtMlstringDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            match artifact {
                DeserializerArtifact::None => Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event,
                    allow_any,
                }),
                DeserializerArtifact::Data(data) => {
                    self.store_content(data)?;
                    let data = self.finish(helper)?;
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(data),
                        event,
                        allow_any,
                    })
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::Content__(deserializer);
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event,
                        allow_any,
                    })
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::DtMlstring> for DtMlstringDeserializer {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::DtMlstring> {
            let (Event::Start(x) | Event::Empty(x)) = &event else {
                return Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event: DeserializerEvent::Break(event),
                    allow_any: false,
                });
            };
            Self::from_bytes_start(helper, x)?.next(helper, event)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::DtMlstring> {
            use DtMlstringDeserializerState as S;
            match replace(&mut *self.state__, S::Unknown__) {
                S::Unknown__ => unreachable!(),
                S::Init__ => {
                    let output = ContentDeserializer::init(helper, event)?;
                    self.handle_content(helper, output)
                }
                S::Content__(deserializer) => {
                    let output = deserializer.next(helper, event)?;
                    self.handle_content(helper, output)
                }
            }
        }
        fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::DtMlstring, Error> {
            let state = replace(&mut *self.state__, DtMlstringDeserializerState::Unknown__);
            self.finish_state(helper, state)?;
            Ok(super::DtMlstring {
                lang: self.lang,
                content: helper.finish_content(self.content)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct CatalogDatetimeElementTypeDeserializer {
        type_: super::CatalogDatetimeType,
        date: Option<String>,
        time: Option<String>,
        timezone: Option<String>,
        state__: Box<CatalogDatetimeElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum CatalogDatetimeElementTypeDeserializerState {
        Init__,
        Date(Option<<String as WithDeserializer>::Deserializer>),
        Time(Option<<String as WithDeserializer>::Deserializer>),
        Timezone(Option<<String as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl CatalogDatetimeElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut type_: Option<super::CatalogDatetimeType> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"type")
                ) {
                    helper.read_attrib(&mut type_, b"type", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                type_: type_.ok_or_else(|| ErrorKind::MissingAttribute("type".into()))?,
                date: None,
                time: None,
                timezone: None,
                state__: Box::new(CatalogDatetimeElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: CatalogDatetimeElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use CatalogDatetimeElementTypeDeserializerState as S;
            match state {
                S::Date(Some(deserializer)) => self.store_date(deserializer.finish(helper)?)?,
                S::Time(Some(deserializer)) => self.store_time(deserializer.finish(helper)?)?,
                S::Timezone(Some(deserializer)) => {
                    self.store_timezone(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_date(&mut self, value: String) -> Result<(), Error> {
            if self.date.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"DATE")))?;
            }
            self.date = Some(value);
            Ok(())
        }
        fn store_time(&mut self, value: String) -> Result<(), Error> {
            if self.time.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"TIME")))?;
            }
            self.time = Some(value);
            Ok(())
        }
        fn store_timezone(&mut self, value: String) -> Result<(), Error> {
            if self.timezone.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"TIMEZONE",
                )))?;
            }
            self.timezone = Some(value);
            Ok(())
        }
        fn handle_date<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<CatalogDatetimeElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use CatalogDatetimeElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::Date(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_date(data)?;
                    *self.state__ = S::Time(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Date(Some(deserializer)));
                    *self.state__ = S::Time(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_time<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<CatalogDatetimeElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use CatalogDatetimeElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Timezone(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_time(data)?;
                    *self.state__ = S::Timezone(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Time(Some(deserializer)));
                    *self.state__ = S::Timezone(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_timezone<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<CatalogDatetimeElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use CatalogDatetimeElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Done__;
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_timezone(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Timezone(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::CatalogDatetimeElementType>
        for CatalogDatetimeElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::CatalogDatetimeElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::CatalogDatetimeElementType> {
            use CatalogDatetimeElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::Date(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_date(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Time(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_time(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Timezone(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_timezone(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::Date(None);
                        event
                    }
                    (S::Date(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"DATE",
                            false,
                        )?;
                        match self.handle_date(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Time(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"TIME",
                            false,
                        )?;
                        match self.handle_time(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Timezone(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"TIMEZONE",
                            false,
                        )?;
                        match self.handle_timezone(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::CatalogDatetimeElementType, Error> {
            let state = replace(
                &mut *self.state__,
                CatalogDatetimeElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::CatalogDatetimeElementType {
                type_: self.type_,
                date: helper.finish_element("DATE", self.date)?,
                time: self.time,
                timezone: self.timezone,
            })
        }
    }
    #[derive(Debug)]
    pub struct TypePartyIdDeserializer {
        type_: Option<String>,
        content: Option<String>,
        state__: Box<TypePartyIdDeserializerState>,
    }
    #[derive(Debug)]
    enum TypePartyIdDeserializerState {
        Init__,
        Content__(<String as WithDeserializer>::Deserializer),
        Unknown__,
    }
    impl TypePartyIdDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut type_: Option<String> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"type")
                ) {
                    helper.read_attrib(&mut type_, b"type", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                type_: type_,
                content: None,
                state__: Box::new(TypePartyIdDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: TypePartyIdDeserializerState,
        ) -> Result<(), Error> {
            if let TypePartyIdDeserializerState::Content__(deserializer) = state {
                self.store_content(deserializer.finish(helper)?)?;
            }
            Ok(())
        }
        fn store_content(&mut self, value: String) -> Result<(), Error> {
            if self.content.is_some() {
                Err(ErrorKind::DuplicateContent)?;
            }
            self.content = Some(value);
            Ok(())
        }
        fn handle_content<'de>(
            mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
        ) -> DeserializerResult<'de, super::TypePartyId> {
            use TypePartyIdDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            match artifact {
                DeserializerArtifact::None => Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event,
                    allow_any,
                }),
                DeserializerArtifact::Data(data) => {
                    self.store_content(data)?;
                    let data = self.finish(helper)?;
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(data),
                        event,
                        allow_any,
                    })
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::Content__(deserializer);
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event,
                        allow_any,
                    })
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::TypePartyId> for TypePartyIdDeserializer {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::TypePartyId> {
            let (Event::Start(x) | Event::Empty(x)) = &event else {
                return Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event: DeserializerEvent::Break(event),
                    allow_any: false,
                });
            };
            Self::from_bytes_start(helper, x)?.next(helper, event)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::TypePartyId> {
            use TypePartyIdDeserializerState as S;
            match replace(&mut *self.state__, S::Unknown__) {
                S::Unknown__ => unreachable!(),
                S::Init__ => {
                    let output = ContentDeserializer::init(helper, event)?;
                    self.handle_content(helper, output)
                }
                S::Content__(deserializer) => {
                    let output = deserializer.next(helper, event)?;
                    self.handle_content(helper, output)
                }
            }
        }
        fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::TypePartyId, Error> {
            let state = replace(&mut *self.state__, TypePartyIdDeserializerState::Unknown__);
            self.finish_state(helper, state)?;
            Ok(super::TypePartyId {
                type_: self.type_,
                content: helper.finish_content(self.content)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct SupplierAddressElementTypeDeserializer {
        type_: super::SupplierAddressType,
        contact: Vec<super::DtMlstring>,
        street: Vec<super::DtMlstring>,
        zip: Vec<super::DtMlstring>,
        city: Vec<super::DtMlstring>,
        country: Vec<super::DtMlstring>,
        vat_id: Option<String>,
        email: Option<String>,
        url: Option<String>,
        state__: Box<SupplierAddressElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum SupplierAddressElementTypeDeserializerState {
        Init__,
        Contact(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        Street(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        Zip(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        City(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        Country(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        VatId(Option<<String as WithDeserializer>::Deserializer>),
        Email(Option<<String as WithDeserializer>::Deserializer>),
        Url(Option<<String as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl SupplierAddressElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut type_: Option<super::SupplierAddressType> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"type")
                ) {
                    helper.read_attrib(&mut type_, b"type", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                type_: type_.ok_or_else(|| ErrorKind::MissingAttribute("type".into()))?,
                contact: Vec::new(),
                street: Vec::new(),
                zip: Vec::new(),
                city: Vec::new(),
                country: Vec::new(),
                vat_id: None,
                email: None,
                url: None,
                state__: Box::new(SupplierAddressElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: SupplierAddressElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use SupplierAddressElementTypeDeserializerState as S;
            match state {
                S::Contact(Some(deserializer)) => {
                    self.store_contact(deserializer.finish(helper)?)?
                }
                S::Street(Some(deserializer)) => self.store_street(deserializer.finish(helper)?)?,
                S::Zip(Some(deserializer)) => self.store_zip(deserializer.finish(helper)?)?,
                S::City(Some(deserializer)) => self.store_city(deserializer.finish(helper)?)?,
                S::Country(Some(deserializer)) => {
                    self.store_country(deserializer.finish(helper)?)?
                }
                S::VatId(Some(deserializer)) => self.store_vat_id(deserializer.finish(helper)?)?,
                S::Email(Some(deserializer)) => self.store_email(deserializer.finish(helper)?)?,
                S::Url(Some(deserializer)) => self.store_url(deserializer.finish(helper)?)?,
                _ => (),
            }
            Ok(())
        }
        fn store_contact(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.contact.push(value);
            Ok(())
        }
        fn store_street(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.street.push(value);
            Ok(())
        }
        fn store_zip(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.zip.push(value);
            Ok(())
        }
        fn store_city(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.city.push(value);
            Ok(())
        }
        fn store_country(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.country.push(value);
            Ok(())
        }
        fn store_vat_id(&mut self, value: String) -> Result<(), Error> {
            if self.vat_id.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"VAT_ID",
                )))?;
            }
            self.vat_id = Some(value);
            Ok(())
        }
        fn store_email(&mut self, value: String) -> Result<(), Error> {
            if self.email.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"EMAIL",
                )))?;
            }
            self.email = Some(value);
            Ok(())
        }
        fn store_url(&mut self, value: String) -> Result<(), Error> {
            if self.url.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"URL")))?;
            }
            self.url = Some(value);
            Ok(())
        }
        fn handle_contact<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<SupplierAddressElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use SupplierAddressElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Street(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_contact(data)?;
                    *self.state__ = S::Contact(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Contact(Some(deserializer)));
                    *self.state__ = S::Contact(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_street<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<SupplierAddressElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use SupplierAddressElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Zip(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_street(data)?;
                    *self.state__ = S::Street(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Street(Some(deserializer)));
                    *self.state__ = S::Street(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_zip<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<SupplierAddressElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use SupplierAddressElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::City(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_zip(data)?;
                    *self.state__ = S::Zip(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Zip(Some(deserializer)));
                    *self.state__ = S::Zip(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_city<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<SupplierAddressElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use SupplierAddressElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Country(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_city(data)?;
                    *self.state__ = S::City(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::City(Some(deserializer)));
                    *self.state__ = S::City(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_country<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<SupplierAddressElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use SupplierAddressElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::VatId(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_country(data)?;
                    *self.state__ = S::Country(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Country(Some(deserializer)));
                    *self.state__ = S::Country(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_vat_id<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<SupplierAddressElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use SupplierAddressElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Email(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_vat_id(data)?;
                    *self.state__ = S::Email(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::VatId(Some(deserializer)));
                    *self.state__ = S::Email(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_email<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<SupplierAddressElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use SupplierAddressElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::Email(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_email(data)?;
                    *self.state__ = S::Url(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Email(Some(deserializer)));
                    *self.state__ = S::Url(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_url<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<SupplierAddressElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use SupplierAddressElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Done__;
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_url(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Url(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::SupplierAddressElementType>
        for SupplierAddressElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::SupplierAddressElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::SupplierAddressElementType> {
            use SupplierAddressElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::Contact(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_contact(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Street(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_street(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Zip(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_zip(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::City(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_city(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Country(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_country(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::VatId(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_vat_id(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Email(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_email(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Url(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_url(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::Contact(None);
                        event
                    }
                    (S::Contact(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"CONTACT",
                            false,
                        )?;
                        match self.handle_contact(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Street(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"STREET",
                            false,
                        )?;
                        match self.handle_street(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Zip(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"ZIP",
                            false,
                        )?;
                        match self.handle_zip(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::City(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"CITY",
                            false,
                        )?;
                        match self.handle_city(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Country(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"COUNTRY",
                            false,
                        )?;
                        match self.handle_country(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::VatId(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"VAT_ID",
                            false,
                        )?;
                        match self.handle_vat_id(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Email(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"EMAIL",
                            false,
                        )?;
                        match self.handle_email(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Url(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"URL",
                            false,
                        )?;
                        match self.handle_url(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::SupplierAddressElementType, Error> {
            let state = replace(
                &mut *self.state__,
                SupplierAddressElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::SupplierAddressElementType {
                type_: self.type_,
                contact: self.contact,
                street: self.street,
                zip: self.zip,
                city: self.city,
                country: self.country,
                vat_id: self.vat_id,
                email: helper.finish_element("EMAIL", self.email)?,
                url: self.url,
            })
        }
    }
    #[derive(Debug)]
    pub struct MimeInfoElementTypeDeserializer {
        mime: Vec<super::MimeElementType>,
        state__: Box<MimeInfoElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum MimeInfoElementTypeDeserializerState {
        Init__,
        Mime(Option<<super::MimeElementType as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl MimeInfoElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                mime: Vec::new(),
                state__: Box::new(MimeInfoElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: MimeInfoElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use MimeInfoElementTypeDeserializerState as S;
            match state {
                S::Mime(Some(deserializer)) => self.store_mime(deserializer.finish(helper)?)?,
                _ => (),
            }
            Ok(())
        }
        fn store_mime(&mut self, value: super::MimeElementType) -> Result<(), Error> {
            self.mime.push(value);
            Ok(())
        }
        fn handle_mime<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::MimeElementType>,
            fallback: &mut Option<MimeInfoElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use MimeInfoElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.mime.len() < 1usize {
                    fallback.get_or_insert(S::Mime(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_mime(data)?;
                    *self.state__ = S::Mime(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Mime(Some(deserializer)));
                    *self.state__ = S::Mime(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::MimeInfoElementType> for MimeInfoElementTypeDeserializer {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::MimeInfoElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::MimeInfoElementType> {
            use MimeInfoElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::Mime(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_mime(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::Mime(None);
                        event
                    }
                    (S::Mime(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"MIME",
                            false,
                        )?;
                        match self.handle_mime(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::MimeInfoElementType, Error> {
            let state = replace(
                &mut *self.state__,
                MimeInfoElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::MimeInfoElementType {
                mime: helper.finish_vec(1usize, None, self.mime)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct SupplierPidElementTypeDeserializer {
        type_: Option<String>,
        content: Option<String>,
        state__: Box<SupplierPidElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum SupplierPidElementTypeDeserializerState {
        Init__,
        Content__(<String as WithDeserializer>::Deserializer),
        Unknown__,
    }
    impl SupplierPidElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut type_: Option<String> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"type")
                ) {
                    helper.read_attrib(&mut type_, b"type", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                type_: type_,
                content: None,
                state__: Box::new(SupplierPidElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: SupplierPidElementTypeDeserializerState,
        ) -> Result<(), Error> {
            if let SupplierPidElementTypeDeserializerState::Content__(deserializer) = state {
                self.store_content(deserializer.finish(helper)?)?;
            }
            Ok(())
        }
        fn store_content(&mut self, value: String) -> Result<(), Error> {
            if self.content.is_some() {
                Err(ErrorKind::DuplicateContent)?;
            }
            self.content = Some(value);
            Ok(())
        }
        fn handle_content<'de>(
            mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
        ) -> DeserializerResult<'de, super::SupplierPidElementType> {
            use SupplierPidElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            match artifact {
                DeserializerArtifact::None => Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event,
                    allow_any,
                }),
                DeserializerArtifact::Data(data) => {
                    self.store_content(data)?;
                    let data = self.finish(helper)?;
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(data),
                        event,
                        allow_any,
                    })
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::Content__(deserializer);
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event,
                        allow_any,
                    })
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::SupplierPidElementType> for SupplierPidElementTypeDeserializer {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::SupplierPidElementType> {
            let (Event::Start(x) | Event::Empty(x)) = &event else {
                return Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event: DeserializerEvent::Break(event),
                    allow_any: false,
                });
            };
            Self::from_bytes_start(helper, x)?.next(helper, event)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::SupplierPidElementType> {
            use SupplierPidElementTypeDeserializerState as S;
            match replace(&mut *self.state__, S::Unknown__) {
                S::Unknown__ => unreachable!(),
                S::Init__ => {
                    let output = ContentDeserializer::init(helper, event)?;
                    self.handle_content(helper, output)
                }
                S::Content__(deserializer) => {
                    let output = deserializer.next(helper, event)?;
                    self.handle_content(helper, output)
                }
            }
        }
        fn finish(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::SupplierPidElementType, Error> {
            let state = replace(
                &mut *self.state__,
                SupplierPidElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::SupplierPidElementType {
                type_: self.type_,
                content: helper.finish_content(self.content)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct ProductDetailsElementTypeDeserializer {
        description_short: Vec<super::DtMlstring>,
        description_long: Vec<super::DtMlstring>,
        international_pid: Vec<super::InternationalPidElementType>,
        supplier_alt_pid: Option<String>,
        buyer_pid: Vec<super::BuyerPidElementType>,
        manufacturer_pid: Option<String>,
        manufacturer_name: Option<String>,
        manufacturer_type_descr: Vec<super::DtMlstring>,
        special_treatment_class: Vec<super::SpecialTreatmentClassElementType>,
        keyword: Vec<super::DtMlstring>,
        remarks: Vec<super::RemarksElementType>,
        product_status: Vec<super::ProductStatusElementType>,
        state__: Box<ProductDetailsElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum ProductDetailsElementTypeDeserializerState {
        Init__,
        DescriptionShort(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        DescriptionLong(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        InternationalPid(
            Option<<super::InternationalPidElementType as WithDeserializer>::Deserializer>,
        ),
        SupplierAltPid(Option<<String as WithDeserializer>::Deserializer>),
        BuyerPid(Option<<super::BuyerPidElementType as WithDeserializer>::Deserializer>),
        ManufacturerPid(Option<<String as WithDeserializer>::Deserializer>),
        ManufacturerName(Option<<String as WithDeserializer>::Deserializer>),
        ManufacturerTypeDescr(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        SpecialTreatmentClass(
            Option<<super::SpecialTreatmentClassElementType as WithDeserializer>::Deserializer>,
        ),
        Keyword(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        Remarks(Option<<super::RemarksElementType as WithDeserializer>::Deserializer>),
        ProductStatus(Option<<super::ProductStatusElementType as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl ProductDetailsElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                description_short: Vec::new(),
                description_long: Vec::new(),
                international_pid: Vec::new(),
                supplier_alt_pid: None,
                buyer_pid: Vec::new(),
                manufacturer_pid: None,
                manufacturer_name: None,
                manufacturer_type_descr: Vec::new(),
                special_treatment_class: Vec::new(),
                keyword: Vec::new(),
                remarks: Vec::new(),
                product_status: Vec::new(),
                state__: Box::new(ProductDetailsElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: ProductDetailsElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use ProductDetailsElementTypeDeserializerState as S;
            match state {
                S::DescriptionShort(Some(deserializer)) => {
                    self.store_description_short(deserializer.finish(helper)?)?
                }
                S::DescriptionLong(Some(deserializer)) => {
                    self.store_description_long(deserializer.finish(helper)?)?
                }
                S::InternationalPid(Some(deserializer)) => {
                    self.store_international_pid(deserializer.finish(helper)?)?
                }
                S::SupplierAltPid(Some(deserializer)) => {
                    self.store_supplier_alt_pid(deserializer.finish(helper)?)?
                }
                S::BuyerPid(Some(deserializer)) => {
                    self.store_buyer_pid(deserializer.finish(helper)?)?
                }
                S::ManufacturerPid(Some(deserializer)) => {
                    self.store_manufacturer_pid(deserializer.finish(helper)?)?
                }
                S::ManufacturerName(Some(deserializer)) => {
                    self.store_manufacturer_name(deserializer.finish(helper)?)?
                }
                S::ManufacturerTypeDescr(Some(deserializer)) => {
                    self.store_manufacturer_type_descr(deserializer.finish(helper)?)?
                }
                S::SpecialTreatmentClass(Some(deserializer)) => {
                    self.store_special_treatment_class(deserializer.finish(helper)?)?
                }
                S::Keyword(Some(deserializer)) => {
                    self.store_keyword(deserializer.finish(helper)?)?
                }
                S::Remarks(Some(deserializer)) => {
                    self.store_remarks(deserializer.finish(helper)?)?
                }
                S::ProductStatus(Some(deserializer)) => {
                    self.store_product_status(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_description_short(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.description_short.push(value);
            Ok(())
        }
        fn store_description_long(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.description_long.push(value);
            Ok(())
        }
        fn store_international_pid(
            &mut self,
            value: super::InternationalPidElementType,
        ) -> Result<(), Error> {
            self.international_pid.push(value);
            Ok(())
        }
        fn store_supplier_alt_pid(&mut self, value: String) -> Result<(), Error> {
            if self.supplier_alt_pid.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"SUPPLIER_ALT_PID",
                )))?;
            }
            self.supplier_alt_pid = Some(value);
            Ok(())
        }
        fn store_buyer_pid(&mut self, value: super::BuyerPidElementType) -> Result<(), Error> {
            self.buyer_pid.push(value);
            Ok(())
        }
        fn store_manufacturer_pid(&mut self, value: String) -> Result<(), Error> {
            if self.manufacturer_pid.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"MANUFACTURER_PID",
                )))?;
            }
            self.manufacturer_pid = Some(value);
            Ok(())
        }
        fn store_manufacturer_name(&mut self, value: String) -> Result<(), Error> {
            if self.manufacturer_name.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"MANUFACTURER_NAME",
                )))?;
            }
            self.manufacturer_name = Some(value);
            Ok(())
        }
        fn store_manufacturer_type_descr(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.manufacturer_type_descr.push(value);
            Ok(())
        }
        fn store_special_treatment_class(
            &mut self,
            value: super::SpecialTreatmentClassElementType,
        ) -> Result<(), Error> {
            self.special_treatment_class.push(value);
            Ok(())
        }
        fn store_keyword(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.keyword.push(value);
            Ok(())
        }
        fn store_remarks(&mut self, value: super::RemarksElementType) -> Result<(), Error> {
            self.remarks.push(value);
            Ok(())
        }
        fn store_product_status(
            &mut self,
            value: super::ProductStatusElementType,
        ) -> Result<(), Error> {
            self.product_status.push(value);
            Ok(())
        }
        fn handle_description_short<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<ProductDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.description_short.len() < 1usize {
                    fallback.get_or_insert(S::DescriptionShort(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::DescriptionLong(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_description_short(data)?;
                    *self.state__ = S::DescriptionShort(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::DescriptionShort(Some(deserializer)));
                    *self.state__ = S::DescriptionShort(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_description_long<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<ProductDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::InternationalPid(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_description_long(data)?;
                    *self.state__ = S::DescriptionLong(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::DescriptionLong(Some(deserializer)));
                    *self.state__ = S::DescriptionLong(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_international_pid<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::InternationalPidElementType>,
            fallback: &mut Option<ProductDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::SupplierAltPid(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_international_pid(data)?;
                    *self.state__ = S::InternationalPid(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::InternationalPid(Some(deserializer)));
                    *self.state__ = S::InternationalPid(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_supplier_alt_pid<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<ProductDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::BuyerPid(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_supplier_alt_pid(data)?;
                    *self.state__ = S::BuyerPid(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::SupplierAltPid(Some(deserializer)));
                    *self.state__ = S::BuyerPid(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_buyer_pid<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::BuyerPidElementType>,
            fallback: &mut Option<ProductDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::ManufacturerPid(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_buyer_pid(data)?;
                    *self.state__ = S::BuyerPid(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::BuyerPid(Some(deserializer)));
                    *self.state__ = S::BuyerPid(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_manufacturer_pid<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<ProductDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::ManufacturerName(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_manufacturer_pid(data)?;
                    *self.state__ = S::ManufacturerName(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ManufacturerPid(Some(deserializer)));
                    *self.state__ = S::ManufacturerName(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_manufacturer_name<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<ProductDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::ManufacturerTypeDescr(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_manufacturer_name(data)?;
                    *self.state__ = S::ManufacturerTypeDescr(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ManufacturerName(Some(deserializer)));
                    *self.state__ = S::ManufacturerTypeDescr(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_manufacturer_type_descr<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<ProductDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::SpecialTreatmentClass(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_manufacturer_type_descr(data)?;
                    *self.state__ = S::ManufacturerTypeDescr(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ManufacturerTypeDescr(Some(deserializer)));
                    *self.state__ = S::ManufacturerTypeDescr(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_special_treatment_class<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::SpecialTreatmentClassElementType>,
            fallback: &mut Option<ProductDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Keyword(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_special_treatment_class(data)?;
                    *self.state__ = S::SpecialTreatmentClass(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::SpecialTreatmentClass(Some(deserializer)));
                    *self.state__ = S::SpecialTreatmentClass(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_keyword<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<ProductDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Remarks(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_keyword(data)?;
                    *self.state__ = S::Keyword(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Keyword(Some(deserializer)));
                    *self.state__ = S::Keyword(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_remarks<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::RemarksElementType>,
            fallback: &mut Option<ProductDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::ProductStatus(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_remarks(data)?;
                    *self.state__ = S::Remarks(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Remarks(Some(deserializer)));
                    *self.state__ = S::Remarks(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_product_status<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::ProductStatusElementType>,
            fallback: &mut Option<ProductDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Done__;
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product_status(data)?;
                    *self.state__ = S::ProductStatus(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ProductStatus(Some(deserializer)));
                    *self.state__ = S::ProductStatus(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::ProductDetailsElementType>
        for ProductDetailsElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductDetailsElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductDetailsElementType> {
            use ProductDetailsElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::DescriptionShort(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_description_short(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::DescriptionLong(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_description_long(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::InternationalPid(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_international_pid(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::SupplierAltPid(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_supplier_alt_pid(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::BuyerPid(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_buyer_pid(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ManufacturerPid(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_manufacturer_pid(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ManufacturerName(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_manufacturer_name(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ManufacturerTypeDescr(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_manufacturer_type_descr(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::SpecialTreatmentClass(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_special_treatment_class(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Keyword(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_keyword(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Remarks(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_remarks(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductStatus(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product_status(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::DescriptionShort(None);
                        event
                    }
                    (S::DescriptionShort(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"DESCRIPTION_SHORT",
                            false,
                        )?;
                        match self.handle_description_short(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::DescriptionLong(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"DESCRIPTION_LONG",
                            false,
                        )?;
                        match self.handle_description_long(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::InternationalPid(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"INTERNATIONAL_PID",
                            false,
                        )?;
                        match self.handle_international_pid(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::SupplierAltPid(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"SUPPLIER_ALT_PID",
                            false,
                        )?;
                        match self.handle_supplier_alt_pid(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::BuyerPid(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"BUYER_PID",
                            false,
                        )?;
                        match self.handle_buyer_pid(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ManufacturerPid(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"MANUFACTURER_PID",
                            false,
                        )?;
                        match self.handle_manufacturer_pid(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ManufacturerName(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"MANUFACTURER_NAME",
                            false,
                        )?;
                        match self.handle_manufacturer_name(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::ManufacturerTypeDescr(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"MANUFACTURER_TYPE_DESCR",
                            false,
                        )?;
                        match self.handle_manufacturer_type_descr(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::SpecialTreatmentClass(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"SPECIAL_TREATMENT_CLASS",
                            false,
                        )?;
                        match self.handle_special_treatment_class(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Keyword(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"KEYWORD",
                            false,
                        )?;
                        match self.handle_keyword(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Remarks(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"REMARKS",
                            false,
                        )?;
                        match self.handle_remarks(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductStatus(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT_STATUS",
                            false,
                        )?;
                        match self.handle_product_status(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::ProductDetailsElementType, Error> {
            let state = replace(
                &mut *self.state__,
                ProductDetailsElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::ProductDetailsElementType {
                description_short: helper.finish_vec(1usize, None, self.description_short)?,
                description_long: self.description_long,
                international_pid: self.international_pid,
                supplier_alt_pid: self.supplier_alt_pid,
                buyer_pid: self.buyer_pid,
                manufacturer_pid: self.manufacturer_pid,
                manufacturer_name: self.manufacturer_name,
                manufacturer_type_descr: self.manufacturer_type_descr,
                special_treatment_class: self.special_treatment_class,
                keyword: self.keyword,
                remarks: self.remarks,
                product_status: self.product_status,
            })
        }
    }
    #[derive(Debug)]
    pub struct ProductFeaturesElementTypeDeserializer {
        reference_feature_system_name: Option<String>,
        reference_feature_group_id: Option<super::TypeClassificationGroupId>,
        feature: Vec<super::FeatureElementType>,
        state__: Box<ProductFeaturesElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum ProductFeaturesElementTypeDeserializerState {
        Init__,
        ReferenceFeatureSystemName(Option<<String as WithDeserializer>::Deserializer>),
        ReferenceFeatureGroupId(
            Option<<super::TypeClassificationGroupId as WithDeserializer>::Deserializer>,
        ),
        Feature(Option<<super::FeatureElementType as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl ProductFeaturesElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                reference_feature_system_name: None,
                reference_feature_group_id: None,
                feature: Vec::new(),
                state__: Box::new(ProductFeaturesElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: ProductFeaturesElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use ProductFeaturesElementTypeDeserializerState as S;
            match state {
                S::ReferenceFeatureSystemName(Some(deserializer)) => {
                    self.store_reference_feature_system_name(deserializer.finish(helper)?)?
                }
                S::ReferenceFeatureGroupId(Some(deserializer)) => {
                    self.store_reference_feature_group_id(deserializer.finish(helper)?)?
                }
                S::Feature(Some(deserializer)) => {
                    self.store_feature(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_reference_feature_system_name(&mut self, value: String) -> Result<(), Error> {
            if self.reference_feature_system_name.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"REFERENCE_FEATURE_SYSTEM_NAME",
                )))?;
            }
            self.reference_feature_system_name = Some(value);
            Ok(())
        }
        fn store_reference_feature_group_id(
            &mut self,
            value: super::TypeClassificationGroupId,
        ) -> Result<(), Error> {
            if self.reference_feature_group_id.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"REFERENCE_FEATURE_GROUP_ID",
                )))?;
            }
            self.reference_feature_group_id = Some(value);
            Ok(())
        }
        fn store_feature(&mut self, value: super::FeatureElementType) -> Result<(), Error> {
            self.feature.push(value);
            Ok(())
        }
        fn handle_reference_feature_system_name<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<ProductFeaturesElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductFeaturesElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::ReferenceFeatureSystemName(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_reference_feature_system_name(data)?;
                    *self.state__ = S::ReferenceFeatureGroupId(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ReferenceFeatureSystemName(Some(deserializer)));
                    *self.state__ = S::ReferenceFeatureGroupId(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_reference_feature_group_id<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::TypeClassificationGroupId>,
            fallback: &mut Option<ProductFeaturesElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductFeaturesElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::ReferenceFeatureGroupId(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_reference_feature_group_id(data)?;
                    *self.state__ = S::Feature(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ReferenceFeatureGroupId(Some(deserializer)));
                    *self.state__ = S::Feature(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_feature<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::FeatureElementType>,
            fallback: &mut Option<ProductFeaturesElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductFeaturesElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.feature.len() < 1usize {
                    fallback.get_or_insert(S::Feature(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_feature(data)?;
                    *self.state__ = S::Feature(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Feature(Some(deserializer)));
                    *self.state__ = S::Feature(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::ProductFeaturesElementType>
        for ProductFeaturesElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductFeaturesElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductFeaturesElementType> {
            use ProductFeaturesElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::ReferenceFeatureSystemName(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_reference_feature_system_name(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ReferenceFeatureGroupId(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_reference_feature_group_id(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Feature(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_feature(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::ReferenceFeatureSystemName(None);
                        event
                    }
                    (
                        S::ReferenceFeatureSystemName(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"REFERENCE_FEATURE_SYSTEM_NAME",
                            false,
                        )?;
                        match self.handle_reference_feature_system_name(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::ReferenceFeatureGroupId(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"REFERENCE_FEATURE_GROUP_ID",
                            false,
                        )?;
                        match self.handle_reference_feature_group_id(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Feature(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"FEATURE",
                            false,
                        )?;
                        match self.handle_feature(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::ProductFeaturesElementType, Error> {
            let state = replace(
                &mut *self.state__,
                ProductFeaturesElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::ProductFeaturesElementType {
                reference_feature_system_name: helper.finish_element(
                    "REFERENCE_FEATURE_SYSTEM_NAME",
                    self.reference_feature_system_name,
                )?,
                reference_feature_group_id: helper.finish_element(
                    "REFERENCE_FEATURE_GROUP_ID",
                    self.reference_feature_group_id,
                )?,
                feature: helper.finish_vec(1usize, None, self.feature)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct ProductOrderDetailsElementTypeDeserializer {
        order_unit: Option<super::DtPunit>,
        content_unit: Option<super::DtPunit>,
        no_cu_per_ou: Option<f64>,
        price_quantity: Option<f64>,
        quantity_min: Option<f32>,
        quantity_interval: Option<f32>,
        state__: Box<ProductOrderDetailsElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum ProductOrderDetailsElementTypeDeserializerState {
        Init__,
        OrderUnit(Option<<super::DtPunit as WithDeserializer>::Deserializer>),
        ContentUnit(Option<<super::DtPunit as WithDeserializer>::Deserializer>),
        NoCuPerOu(Option<<f64 as WithDeserializer>::Deserializer>),
        PriceQuantity(Option<<f64 as WithDeserializer>::Deserializer>),
        QuantityMin(Option<<f32 as WithDeserializer>::Deserializer>),
        QuantityInterval(Option<<f32 as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl ProductOrderDetailsElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                order_unit: None,
                content_unit: None,
                no_cu_per_ou: None,
                price_quantity: None,
                quantity_min: None,
                quantity_interval: None,
                state__: Box::new(ProductOrderDetailsElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: ProductOrderDetailsElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use ProductOrderDetailsElementTypeDeserializerState as S;
            match state {
                S::OrderUnit(Some(deserializer)) => {
                    self.store_order_unit(deserializer.finish(helper)?)?
                }
                S::ContentUnit(Some(deserializer)) => {
                    self.store_content_unit(deserializer.finish(helper)?)?
                }
                S::NoCuPerOu(Some(deserializer)) => {
                    self.store_no_cu_per_ou(deserializer.finish(helper)?)?
                }
                S::PriceQuantity(Some(deserializer)) => {
                    self.store_price_quantity(deserializer.finish(helper)?)?
                }
                S::QuantityMin(Some(deserializer)) => {
                    self.store_quantity_min(deserializer.finish(helper)?)?
                }
                S::QuantityInterval(Some(deserializer)) => {
                    self.store_quantity_interval(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_order_unit(&mut self, value: super::DtPunit) -> Result<(), Error> {
            if self.order_unit.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"ORDER_UNIT",
                )))?;
            }
            self.order_unit = Some(value);
            Ok(())
        }
        fn store_content_unit(&mut self, value: super::DtPunit) -> Result<(), Error> {
            if self.content_unit.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"CONTENT_UNIT",
                )))?;
            }
            self.content_unit = Some(value);
            Ok(())
        }
        fn store_no_cu_per_ou(&mut self, value: f64) -> Result<(), Error> {
            if self.no_cu_per_ou.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"NO_CU_PER_OU",
                )))?;
            }
            self.no_cu_per_ou = Some(value);
            Ok(())
        }
        fn store_price_quantity(&mut self, value: f64) -> Result<(), Error> {
            if self.price_quantity.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"PRICE_QUANTITY",
                )))?;
            }
            self.price_quantity = Some(value);
            Ok(())
        }
        fn store_quantity_min(&mut self, value: f32) -> Result<(), Error> {
            if self.quantity_min.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"QUANTITY_MIN",
                )))?;
            }
            self.quantity_min = Some(value);
            Ok(())
        }
        fn store_quantity_interval(&mut self, value: f32) -> Result<(), Error> {
            if self.quantity_interval.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"QUANTITY_INTERVAL",
                )))?;
            }
            self.quantity_interval = Some(value);
            Ok(())
        }
        fn handle_order_unit<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtPunit>,
            fallback: &mut Option<ProductOrderDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductOrderDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::OrderUnit(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_order_unit(data)?;
                    *self.state__ = S::ContentUnit(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::OrderUnit(Some(deserializer)));
                    *self.state__ = S::ContentUnit(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_content_unit<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtPunit>,
            fallback: &mut Option<ProductOrderDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductOrderDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::ContentUnit(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_content_unit(data)?;
                    *self.state__ = S::NoCuPerOu(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ContentUnit(Some(deserializer)));
                    *self.state__ = S::NoCuPerOu(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_no_cu_per_ou<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f64>,
            fallback: &mut Option<ProductOrderDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductOrderDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::PriceQuantity(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_no_cu_per_ou(data)?;
                    *self.state__ = S::PriceQuantity(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::NoCuPerOu(Some(deserializer)));
                    *self.state__ = S::PriceQuantity(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_price_quantity<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f64>,
            fallback: &mut Option<ProductOrderDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductOrderDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::QuantityMin(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_price_quantity(data)?;
                    *self.state__ = S::QuantityMin(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::PriceQuantity(Some(deserializer)));
                    *self.state__ = S::QuantityMin(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_quantity_min<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f32>,
            fallback: &mut Option<ProductOrderDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductOrderDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::QuantityInterval(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_quantity_min(data)?;
                    *self.state__ = S::QuantityInterval(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::QuantityMin(Some(deserializer)));
                    *self.state__ = S::QuantityInterval(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_quantity_interval<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f32>,
            fallback: &mut Option<ProductOrderDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductOrderDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Done__;
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_quantity_interval(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::QuantityInterval(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::ProductOrderDetailsElementType>
        for ProductOrderDetailsElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductOrderDetailsElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductOrderDetailsElementType> {
            use ProductOrderDetailsElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::OrderUnit(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_order_unit(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ContentUnit(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_content_unit(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::NoCuPerOu(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_no_cu_per_ou(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::PriceQuantity(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_price_quantity(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::QuantityMin(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_quantity_min(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::QuantityInterval(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_quantity_interval(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::OrderUnit(None);
                        event
                    }
                    (S::OrderUnit(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"ORDER_UNIT",
                            false,
                        )?;
                        match self.handle_order_unit(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ContentUnit(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"CONTENT_UNIT",
                            false,
                        )?;
                        match self.handle_content_unit(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::NoCuPerOu(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"NO_CU_PER_OU",
                            false,
                        )?;
                        match self.handle_no_cu_per_ou(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::PriceQuantity(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRICE_QUANTITY",
                            false,
                        )?;
                        match self.handle_price_quantity(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::QuantityMin(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"QUANTITY_MIN",
                            false,
                        )?;
                        match self.handle_quantity_min(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::QuantityInterval(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"QUANTITY_INTERVAL",
                            false,
                        )?;
                        match self.handle_quantity_interval(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::ProductOrderDetailsElementType, Error> {
            let state = replace(
                &mut *self.state__,
                ProductOrderDetailsElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::ProductOrderDetailsElementType {
                order_unit: helper.finish_element("ORDER_UNIT", self.order_unit)?,
                content_unit: helper.finish_element("CONTENT_UNIT", self.content_unit)?,
                no_cu_per_ou: self.no_cu_per_ou,
                price_quantity: self.price_quantity,
                quantity_min: self.quantity_min,
                quantity_interval: self.quantity_interval,
            })
        }
    }
    #[derive(Debug)]
    pub struct ProductPriceDetailsElementTypeDeserializer {
        datetime: Vec<super::ProductPriceDetailsDatetimeElementType>,
        daily_price: Option<String>,
        product_price: Vec<super::ProductPriceElementType>,
        state__: Box<ProductPriceDetailsElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum ProductPriceDetailsElementTypeDeserializerState {
        Init__,
        Datetime(
            Option<
                <super::ProductPriceDetailsDatetimeElementType as WithDeserializer>::Deserializer,
            >,
        ),
        DailyPrice(Option<<String as WithDeserializer>::Deserializer>),
        ProductPrice(Option<<super::ProductPriceElementType as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl ProductPriceDetailsElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                datetime: Vec::new(),
                daily_price: None,
                product_price: Vec::new(),
                state__: Box::new(ProductPriceDetailsElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: ProductPriceDetailsElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use ProductPriceDetailsElementTypeDeserializerState as S;
            match state {
                S::Datetime(Some(deserializer)) => {
                    self.store_datetime(deserializer.finish(helper)?)?
                }
                S::DailyPrice(Some(deserializer)) => {
                    self.store_daily_price(deserializer.finish(helper)?)?
                }
                S::ProductPrice(Some(deserializer)) => {
                    self.store_product_price(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_datetime(
            &mut self,
            value: super::ProductPriceDetailsDatetimeElementType,
        ) -> Result<(), Error> {
            self.datetime.push(value);
            Ok(())
        }
        fn store_daily_price(&mut self, value: String) -> Result<(), Error> {
            if self.daily_price.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"DAILY_PRICE",
                )))?;
            }
            self.daily_price = Some(value);
            Ok(())
        }
        fn store_product_price(
            &mut self,
            value: super::ProductPriceElementType,
        ) -> Result<(), Error> {
            self.product_price.push(value);
            Ok(())
        }
        fn handle_datetime<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::ProductPriceDetailsDatetimeElementType>,
            fallback: &mut Option<ProductPriceDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductPriceDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.datetime.len() < 1usize {
                    fallback.get_or_insert(S::Datetime(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::DailyPrice(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_datetime(data)?;
                    if self.datetime.len() < 2usize {
                        *self.state__ = S::Datetime(None);
                    } else {
                        *self.state__ = S::DailyPrice(None);
                    }
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Datetime(Some(deserializer)));
                    if self.datetime.len() < 1usize {
                        *self.state__ = S::Datetime(None);
                    } else {
                        *self.state__ = S::DailyPrice(None);
                    }
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_daily_price<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<ProductPriceDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductPriceDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::ProductPrice(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_daily_price(data)?;
                    *self.state__ = S::ProductPrice(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::DailyPrice(Some(deserializer)));
                    *self.state__ = S::ProductPrice(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_product_price<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::ProductPriceElementType>,
            fallback: &mut Option<ProductPriceDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductPriceDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.product_price.len() < 1usize {
                    fallback.get_or_insert(S::ProductPrice(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_product_price(data)?;
                    *self.state__ = S::ProductPrice(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ProductPrice(Some(deserializer)));
                    *self.state__ = S::ProductPrice(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::ProductPriceDetailsElementType>
        for ProductPriceDetailsElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductPriceDetailsElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductPriceDetailsElementType> {
            use ProductPriceDetailsElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::Datetime(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_datetime(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::DailyPrice(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_daily_price(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductPrice(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_product_price(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::Datetime(None);
                        event
                    }
                    (S::Datetime(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"DATETIME",
                            false,
                        )?;
                        match self.handle_datetime(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::DailyPrice(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"DAILY_PRICE",
                            false,
                        )?;
                        match self.handle_daily_price(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::ProductPrice(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRODUCT_PRICE",
                            false,
                        )?;
                        match self.handle_product_price(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::ProductPriceDetailsElementType, Error> {
            let state = replace(
                &mut *self.state__,
                ProductPriceDetailsElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::ProductPriceDetailsElementType {
                datetime: helper.finish_vec(1usize, Some(2usize), self.datetime)?,
                daily_price: self.daily_price,
                product_price: helper.finish_vec(1usize, None, self.product_price)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct UdxProductDeserializer {
        udx_edxf_manufacturer_acronym: Option<String>,
        udx_edxf_description_very_short: Vec<super::DtMlstring>,
        udx_edxf_brand_name: Option<String>,
        udx_edxf_tender_text: Vec<super::DtMlstring>,
        udx_edxf_valid_from: Option<String>,
        udx_edxf_expiration_date: Option<String>,
        udx_edxf_discount_group: Option<super::UdxEdxfDiscountGroupElementType>,
        udx_edxf_bonus_group_supplier: Option<String>,
        udx_edxf_pkwiu: Option<String>,
        udx_edxf_declaration: Vec<super::UdxEdxfDeclarationElementType>,
        udx_edxf_additional_factors: Option<super::UdxEdxfAdditionalFactorsElementType>,
        udx_edxf_product_to_stock: Option<String>,
        udx_edxf_product_series: Vec<super::DtMlstring>,
        udx_edxf_product_variation: Vec<super::DtMlstring>,
        udx_edxf_at_reverse_charge_info: Option<String>,
        udx_edxf_country_branch_numbers: Option<super::UdxEdxfCountryBranchNumbersElementType>,
        udx_edxf_country_branch_supplier_ids:
            Option<super::UdxEdxfCountryBranchSupplierIdsElementType>,
        udx_edxf_packing_units: Option<super::UdxEdxfPackingUnitsElementType>,
        udx_edxf_product_logistic_details: Option<super::UdxEdxfProductLogisticDetailsElementType>,
        udx_edxf_reach: Option<super::UdxEdxfReachElementType>,
        udx_edxf_surcharge_list: Option<super::UdxEdxfSurchargeListElementType>,
        state__: Box<UdxProductDeserializerState>,
    }
    #[derive(Debug)]
    enum UdxProductDeserializerState {
        Init__ , UdxEdxfManufacturerAcronym (Option << String as WithDeserializer > :: Deserializer >) , UdxEdxfDescriptionVeryShort (Option << super :: DtMlstring as WithDeserializer > :: Deserializer >) , UdxEdxfBrandName (Option << String as WithDeserializer > :: Deserializer >) , UdxEdxfTenderText (Option << super :: DtMlstring as WithDeserializer > :: Deserializer >) , UdxEdxfValidFrom (Option << String as WithDeserializer > :: Deserializer >) , UdxEdxfExpirationDate (Option << String as WithDeserializer > :: Deserializer >) , UdxEdxfDiscountGroup (Option << super :: UdxEdxfDiscountGroupElementType as WithDeserializer > :: Deserializer >) , UdxEdxfBonusGroupSupplier (Option << String as WithDeserializer > :: Deserializer >) , UdxEdxfPkwiu (Option << String as WithDeserializer > :: Deserializer >) , UdxEdxfDeclaration (Option << super :: UdxEdxfDeclarationElementType as WithDeserializer > :: Deserializer >) , UdxEdxfAdditionalFactors (Option << super :: UdxEdxfAdditionalFactorsElementType as WithDeserializer > :: Deserializer >) , UdxEdxfProductToStock (Option << String as WithDeserializer > :: Deserializer >) , UdxEdxfProductSeries (Option << super :: DtMlstring as WithDeserializer > :: Deserializer >) , UdxEdxfProductVariation (Option << super :: DtMlstring as WithDeserializer > :: Deserializer >) , UdxEdxfAtReverseChargeInfo (Option << String as WithDeserializer > :: Deserializer >) , UdxEdxfCountryBranchNumbers (Option << super :: UdxEdxfCountryBranchNumbersElementType as WithDeserializer > :: Deserializer >) , UdxEdxfCountryBranchSupplierIds (Option << super :: UdxEdxfCountryBranchSupplierIdsElementType as WithDeserializer > :: Deserializer >) , UdxEdxfPackingUnits (Option << super :: UdxEdxfPackingUnitsElementType as WithDeserializer > :: Deserializer >) , UdxEdxfProductLogisticDetails (Option << super :: UdxEdxfProductLogisticDetailsElementType as WithDeserializer > :: Deserializer >) , UdxEdxfReach (Option << super :: UdxEdxfReachElementType as WithDeserializer > :: Deserializer >) , UdxEdxfSurchargeList (Option << super :: UdxEdxfSurchargeListElementType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
    impl UdxProductDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                udx_edxf_manufacturer_acronym: None,
                udx_edxf_description_very_short: Vec::new(),
                udx_edxf_brand_name: None,
                udx_edxf_tender_text: Vec::new(),
                udx_edxf_valid_from: None,
                udx_edxf_expiration_date: None,
                udx_edxf_discount_group: None,
                udx_edxf_bonus_group_supplier: None,
                udx_edxf_pkwiu: None,
                udx_edxf_declaration: Vec::new(),
                udx_edxf_additional_factors: None,
                udx_edxf_product_to_stock: None,
                udx_edxf_product_series: Vec::new(),
                udx_edxf_product_variation: Vec::new(),
                udx_edxf_at_reverse_charge_info: None,
                udx_edxf_country_branch_numbers: None,
                udx_edxf_country_branch_supplier_ids: None,
                udx_edxf_packing_units: None,
                udx_edxf_product_logistic_details: None,
                udx_edxf_reach: None,
                udx_edxf_surcharge_list: None,
                state__: Box::new(UdxProductDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: UdxProductDeserializerState,
        ) -> Result<(), Error> {
            use UdxProductDeserializerState as S;
            match state {
                S::UdxEdxfManufacturerAcronym(Some(deserializer)) => {
                    self.store_udx_edxf_manufacturer_acronym(deserializer.finish(helper)?)?
                }
                S::UdxEdxfDescriptionVeryShort(Some(deserializer)) => {
                    self.store_udx_edxf_description_very_short(deserializer.finish(helper)?)?
                }
                S::UdxEdxfBrandName(Some(deserializer)) => {
                    self.store_udx_edxf_brand_name(deserializer.finish(helper)?)?
                }
                S::UdxEdxfTenderText(Some(deserializer)) => {
                    self.store_udx_edxf_tender_text(deserializer.finish(helper)?)?
                }
                S::UdxEdxfValidFrom(Some(deserializer)) => {
                    self.store_udx_edxf_valid_from(deserializer.finish(helper)?)?
                }
                S::UdxEdxfExpirationDate(Some(deserializer)) => {
                    self.store_udx_edxf_expiration_date(deserializer.finish(helper)?)?
                }
                S::UdxEdxfDiscountGroup(Some(deserializer)) => {
                    self.store_udx_edxf_discount_group(deserializer.finish(helper)?)?
                }
                S::UdxEdxfBonusGroupSupplier(Some(deserializer)) => {
                    self.store_udx_edxf_bonus_group_supplier(deserializer.finish(helper)?)?
                }
                S::UdxEdxfPkwiu(Some(deserializer)) => {
                    self.store_udx_edxf_pkwiu(deserializer.finish(helper)?)?
                }
                S::UdxEdxfDeclaration(Some(deserializer)) => {
                    self.store_udx_edxf_declaration(deserializer.finish(helper)?)?
                }
                S::UdxEdxfAdditionalFactors(Some(deserializer)) => {
                    self.store_udx_edxf_additional_factors(deserializer.finish(helper)?)?
                }
                S::UdxEdxfProductToStock(Some(deserializer)) => {
                    self.store_udx_edxf_product_to_stock(deserializer.finish(helper)?)?
                }
                S::UdxEdxfProductSeries(Some(deserializer)) => {
                    self.store_udx_edxf_product_series(deserializer.finish(helper)?)?
                }
                S::UdxEdxfProductVariation(Some(deserializer)) => {
                    self.store_udx_edxf_product_variation(deserializer.finish(helper)?)?
                }
                S::UdxEdxfAtReverseChargeInfo(Some(deserializer)) => {
                    self.store_udx_edxf_at_reverse_charge_info(deserializer.finish(helper)?)?
                }
                S::UdxEdxfCountryBranchNumbers(Some(deserializer)) => {
                    self.store_udx_edxf_country_branch_numbers(deserializer.finish(helper)?)?
                }
                S::UdxEdxfCountryBranchSupplierIds(Some(deserializer)) => {
                    self.store_udx_edxf_country_branch_supplier_ids(deserializer.finish(helper)?)?
                }
                S::UdxEdxfPackingUnits(Some(deserializer)) => {
                    self.store_udx_edxf_packing_units(deserializer.finish(helper)?)?
                }
                S::UdxEdxfProductLogisticDetails(Some(deserializer)) => {
                    self.store_udx_edxf_product_logistic_details(deserializer.finish(helper)?)?
                }
                S::UdxEdxfReach(Some(deserializer)) => {
                    self.store_udx_edxf_reach(deserializer.finish(helper)?)?
                }
                S::UdxEdxfSurchargeList(Some(deserializer)) => {
                    self.store_udx_edxf_surcharge_list(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_udx_edxf_manufacturer_acronym(&mut self, value: String) -> Result<(), Error> {
            if self.udx_edxf_manufacturer_acronym.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.MANUFACTURER_ACRONYM",
                )))?;
            }
            self.udx_edxf_manufacturer_acronym = Some(value);
            Ok(())
        }
        fn store_udx_edxf_description_very_short(
            &mut self,
            value: super::DtMlstring,
        ) -> Result<(), Error> {
            self.udx_edxf_description_very_short.push(value);
            Ok(())
        }
        fn store_udx_edxf_brand_name(&mut self, value: String) -> Result<(), Error> {
            if self.udx_edxf_brand_name.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.BRAND_NAME",
                )))?;
            }
            self.udx_edxf_brand_name = Some(value);
            Ok(())
        }
        fn store_udx_edxf_tender_text(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.udx_edxf_tender_text.push(value);
            Ok(())
        }
        fn store_udx_edxf_valid_from(&mut self, value: String) -> Result<(), Error> {
            if self.udx_edxf_valid_from.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.VALID_FROM",
                )))?;
            }
            self.udx_edxf_valid_from = Some(value);
            Ok(())
        }
        fn store_udx_edxf_expiration_date(&mut self, value: String) -> Result<(), Error> {
            if self.udx_edxf_expiration_date.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.EXPIRATION_DATE",
                )))?;
            }
            self.udx_edxf_expiration_date = Some(value);
            Ok(())
        }
        fn store_udx_edxf_discount_group(
            &mut self,
            value: super::UdxEdxfDiscountGroupElementType,
        ) -> Result<(), Error> {
            if self.udx_edxf_discount_group.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.DISCOUNT_GROUP",
                )))?;
            }
            self.udx_edxf_discount_group = Some(value);
            Ok(())
        }
        fn store_udx_edxf_bonus_group_supplier(&mut self, value: String) -> Result<(), Error> {
            if self.udx_edxf_bonus_group_supplier.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.BONUS_GROUP_SUPPLIER",
                )))?;
            }
            self.udx_edxf_bonus_group_supplier = Some(value);
            Ok(())
        }
        fn store_udx_edxf_pkwiu(&mut self, value: String) -> Result<(), Error> {
            if self.udx_edxf_pkwiu.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.PKWIU",
                )))?;
            }
            self.udx_edxf_pkwiu = Some(value);
            Ok(())
        }
        fn store_udx_edxf_declaration(
            &mut self,
            value: super::UdxEdxfDeclarationElementType,
        ) -> Result<(), Error> {
            self.udx_edxf_declaration.push(value);
            Ok(())
        }
        fn store_udx_edxf_additional_factors(
            &mut self,
            value: super::UdxEdxfAdditionalFactorsElementType,
        ) -> Result<(), Error> {
            if self.udx_edxf_additional_factors.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.ADDITIONAL_FACTORS",
                )))?;
            }
            self.udx_edxf_additional_factors = Some(value);
            Ok(())
        }
        fn store_udx_edxf_product_to_stock(&mut self, value: String) -> Result<(), Error> {
            if self.udx_edxf_product_to_stock.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.PRODUCT_TO_STOCK",
                )))?;
            }
            self.udx_edxf_product_to_stock = Some(value);
            Ok(())
        }
        fn store_udx_edxf_product_series(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.udx_edxf_product_series.push(value);
            Ok(())
        }
        fn store_udx_edxf_product_variation(
            &mut self,
            value: super::DtMlstring,
        ) -> Result<(), Error> {
            self.udx_edxf_product_variation.push(value);
            Ok(())
        }
        fn store_udx_edxf_at_reverse_charge_info(&mut self, value: String) -> Result<(), Error> {
            if self.udx_edxf_at_reverse_charge_info.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.AT.REVERSE_CHARGE_INFO",
                )))?;
            }
            self.udx_edxf_at_reverse_charge_info = Some(value);
            Ok(())
        }
        fn store_udx_edxf_country_branch_numbers(
            &mut self,
            value: super::UdxEdxfCountryBranchNumbersElementType,
        ) -> Result<(), Error> {
            if self.udx_edxf_country_branch_numbers.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.COUNTRY_BRANCH_NUMBERS",
                )))?;
            }
            self.udx_edxf_country_branch_numbers = Some(value);
            Ok(())
        }
        fn store_udx_edxf_country_branch_supplier_ids(
            &mut self,
            value: super::UdxEdxfCountryBranchSupplierIdsElementType,
        ) -> Result<(), Error> {
            if self.udx_edxf_country_branch_supplier_ids.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.COUNTRY_BRANCH_SUPPLIER_IDS",
                )))?;
            }
            self.udx_edxf_country_branch_supplier_ids = Some(value);
            Ok(())
        }
        fn store_udx_edxf_packing_units(
            &mut self,
            value: super::UdxEdxfPackingUnitsElementType,
        ) -> Result<(), Error> {
            if self.udx_edxf_packing_units.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.PACKING_UNITS",
                )))?;
            }
            self.udx_edxf_packing_units = Some(value);
            Ok(())
        }
        fn store_udx_edxf_product_logistic_details(
            &mut self,
            value: super::UdxEdxfProductLogisticDetailsElementType,
        ) -> Result<(), Error> {
            if self.udx_edxf_product_logistic_details.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.PRODUCT_LOGISTIC_DETAILS",
                )))?;
            }
            self.udx_edxf_product_logistic_details = Some(value);
            Ok(())
        }
        fn store_udx_edxf_reach(
            &mut self,
            value: super::UdxEdxfReachElementType,
        ) -> Result<(), Error> {
            if self.udx_edxf_reach.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.REACH",
                )))?;
            }
            self.udx_edxf_reach = Some(value);
            Ok(())
        }
        fn store_udx_edxf_surcharge_list(
            &mut self,
            value: super::UdxEdxfSurchargeListElementType,
        ) -> Result<(), Error> {
            if self.udx_edxf_surcharge_list.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.SURCHARGE_LIST",
                )))?;
            }
            self.udx_edxf_surcharge_list = Some(value);
            Ok(())
        }
        fn handle_udx_edxf_manufacturer_acronym<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfDescriptionVeryShort(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_manufacturer_acronym(data)?;
                    *self.state__ = S::UdxEdxfDescriptionVeryShort(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfManufacturerAcronym(Some(deserializer)));
                    *self.state__ = S::UdxEdxfDescriptionVeryShort(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_description_very_short<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfBrandName(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_description_very_short(data)?;
                    *self.state__ = S::UdxEdxfDescriptionVeryShort(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfDescriptionVeryShort(Some(deserializer)));
                    *self.state__ = S::UdxEdxfDescriptionVeryShort(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_brand_name<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfTenderText(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_brand_name(data)?;
                    *self.state__ = S::UdxEdxfTenderText(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfBrandName(Some(deserializer)));
                    *self.state__ = S::UdxEdxfTenderText(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_tender_text<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfValidFrom(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_tender_text(data)?;
                    *self.state__ = S::UdxEdxfTenderText(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfTenderText(Some(deserializer)));
                    *self.state__ = S::UdxEdxfTenderText(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_valid_from<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfExpirationDate(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_valid_from(data)?;
                    *self.state__ = S::UdxEdxfExpirationDate(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfValidFrom(Some(deserializer)));
                    *self.state__ = S::UdxEdxfExpirationDate(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_expiration_date<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfDiscountGroup(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_expiration_date(data)?;
                    *self.state__ = S::UdxEdxfDiscountGroup(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfExpirationDate(Some(deserializer)));
                    *self.state__ = S::UdxEdxfDiscountGroup(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_discount_group<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::UdxEdxfDiscountGroupElementType>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfBonusGroupSupplier(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_discount_group(data)?;
                    *self.state__ = S::UdxEdxfBonusGroupSupplier(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfDiscountGroup(Some(deserializer)));
                    *self.state__ = S::UdxEdxfBonusGroupSupplier(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_bonus_group_supplier<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfPkwiu(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_bonus_group_supplier(data)?;
                    *self.state__ = S::UdxEdxfPkwiu(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfBonusGroupSupplier(Some(deserializer)));
                    *self.state__ = S::UdxEdxfPkwiu(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_pkwiu<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfDeclaration(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_pkwiu(data)?;
                    *self.state__ = S::UdxEdxfDeclaration(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfPkwiu(Some(deserializer)));
                    *self.state__ = S::UdxEdxfDeclaration(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_declaration<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::UdxEdxfDeclarationElementType>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfAdditionalFactors(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_declaration(data)?;
                    *self.state__ = S::UdxEdxfDeclaration(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfDeclaration(Some(deserializer)));
                    *self.state__ = S::UdxEdxfDeclaration(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_additional_factors<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::UdxEdxfAdditionalFactorsElementType>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfProductToStock(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_additional_factors(data)?;
                    *self.state__ = S::UdxEdxfProductToStock(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfAdditionalFactors(Some(deserializer)));
                    *self.state__ = S::UdxEdxfProductToStock(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_product_to_stock<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfProductSeries(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_product_to_stock(data)?;
                    *self.state__ = S::UdxEdxfProductSeries(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfProductToStock(Some(deserializer)));
                    *self.state__ = S::UdxEdxfProductSeries(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_product_series<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfProductVariation(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_product_series(data)?;
                    *self.state__ = S::UdxEdxfProductSeries(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfProductSeries(Some(deserializer)));
                    *self.state__ = S::UdxEdxfProductSeries(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_product_variation<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfAtReverseChargeInfo(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_product_variation(data)?;
                    *self.state__ = S::UdxEdxfProductVariation(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfProductVariation(Some(deserializer)));
                    *self.state__ = S::UdxEdxfProductVariation(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_at_reverse_charge_info<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfCountryBranchNumbers(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_at_reverse_charge_info(data)?;
                    *self.state__ = S::UdxEdxfCountryBranchNumbers(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfAtReverseChargeInfo(Some(deserializer)));
                    *self.state__ = S::UdxEdxfCountryBranchNumbers(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_country_branch_numbers<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::UdxEdxfCountryBranchNumbersElementType>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfCountryBranchSupplierIds(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_country_branch_numbers(data)?;
                    *self.state__ = S::UdxEdxfCountryBranchSupplierIds(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfCountryBranchNumbers(Some(deserializer)));
                    *self.state__ = S::UdxEdxfCountryBranchSupplierIds(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_country_branch_supplier_ids<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::UdxEdxfCountryBranchSupplierIdsElementType>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfPackingUnits(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_country_branch_supplier_ids(data)?;
                    *self.state__ = S::UdxEdxfPackingUnits(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfCountryBranchSupplierIds(Some(deserializer)));
                    *self.state__ = S::UdxEdxfPackingUnits(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_packing_units<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::UdxEdxfPackingUnitsElementType>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfProductLogisticDetails(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_packing_units(data)?;
                    *self.state__ = S::UdxEdxfProductLogisticDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfPackingUnits(Some(deserializer)));
                    *self.state__ = S::UdxEdxfProductLogisticDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_product_logistic_details<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::UdxEdxfProductLogisticDetailsElementType>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfReach(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_product_logistic_details(data)?;
                    *self.state__ = S::UdxEdxfReach(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfProductLogisticDetails(Some(deserializer)));
                    *self.state__ = S::UdxEdxfReach(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_reach<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::UdxEdxfReachElementType>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfSurchargeList(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_reach(data)?;
                    *self.state__ = S::UdxEdxfSurchargeList(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfReach(Some(deserializer)));
                    *self.state__ = S::UdxEdxfSurchargeList(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_surcharge_list<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::UdxEdxfSurchargeListElementType>,
            fallback: &mut Option<UdxProductDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxProductDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Done__;
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_surcharge_list(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfSurchargeList(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::UdxProduct> for UdxProductDeserializer {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxProduct> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxProduct> {
            use UdxProductDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::UdxEdxfManufacturerAcronym(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_manufacturer_acronym(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfDescriptionVeryShort(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_description_very_short(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfBrandName(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_brand_name(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfTenderText(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_tender_text(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfValidFrom(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_valid_from(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfExpirationDate(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_expiration_date(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfDiscountGroup(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_discount_group(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfBonusGroupSupplier(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_bonus_group_supplier(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfPkwiu(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_pkwiu(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfDeclaration(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_declaration(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfAdditionalFactors(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_additional_factors(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfProductToStock(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_product_to_stock(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfProductSeries(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_product_series(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfProductVariation(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_product_variation(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfAtReverseChargeInfo(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_at_reverse_charge_info(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfCountryBranchNumbers(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_country_branch_numbers(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfCountryBranchSupplierIds(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_country_branch_supplier_ids(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfPackingUnits(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_packing_units(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfProductLogisticDetails(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_product_logistic_details(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfReach(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_reach(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfSurchargeList(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_surcharge_list(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::UdxEdxfManufacturerAcronym(None);
                        event
                    }
                    (
                        S::UdxEdxfManufacturerAcronym(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.MANUFACTURER_ACRONYM",
                            false,
                        )?;
                        match self.handle_udx_edxf_manufacturer_acronym(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UdxEdxfDescriptionVeryShort(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.DESCRIPTION_VERY_SHORT",
                            false,
                        )?;
                        match self.handle_udx_edxf_description_very_short(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfBrandName(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.BRAND_NAME",
                            false,
                        )?;
                        match self.handle_udx_edxf_brand_name(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfTenderText(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.TENDER_TEXT",
                            false,
                        )?;
                        match self.handle_udx_edxf_tender_text(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfValidFrom(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.VALID_FROM",
                            false,
                        )?;
                        match self.handle_udx_edxf_valid_from(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UdxEdxfExpirationDate(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.EXPIRATION_DATE",
                            false,
                        )?;
                        match self.handle_udx_edxf_expiration_date(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UdxEdxfDiscountGroup(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.DISCOUNT_GROUP",
                            false,
                        )?;
                        match self.handle_udx_edxf_discount_group(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UdxEdxfBonusGroupSupplier(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.BONUS_GROUP_SUPPLIER",
                            false,
                        )?;
                        match self.handle_udx_edxf_bonus_group_supplier(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfPkwiu(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.PKWIU",
                            false,
                        )?;
                        match self.handle_udx_edxf_pkwiu(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfDeclaration(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.DECLARATION",
                            false,
                        )?;
                        match self.handle_udx_edxf_declaration(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UdxEdxfAdditionalFactors(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.ADDITIONAL_FACTORS",
                            false,
                        )?;
                        match self.handle_udx_edxf_additional_factors(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UdxEdxfProductToStock(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.PRODUCT_TO_STOCK",
                            false,
                        )?;
                        match self.handle_udx_edxf_product_to_stock(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UdxEdxfProductSeries(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.PRODUCT_SERIES",
                            false,
                        )?;
                        match self.handle_udx_edxf_product_series(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UdxEdxfProductVariation(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.PRODUCT_VARIATION",
                            false,
                        )?;
                        match self.handle_udx_edxf_product_variation(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UdxEdxfAtReverseChargeInfo(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.AT.REVERSE_CHARGE_INFO",
                            false,
                        )?;
                        match self.handle_udx_edxf_at_reverse_charge_info(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UdxEdxfCountryBranchNumbers(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.COUNTRY_BRANCH_NUMBERS",
                            false,
                        )?;
                        match self.handle_udx_edxf_country_branch_numbers(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UdxEdxfCountryBranchSupplierIds(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.COUNTRY_BRANCH_SUPPLIER_IDS",
                            false,
                        )?;
                        match self.handle_udx_edxf_country_branch_supplier_ids(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfPackingUnits(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.PACKING_UNITS",
                            false,
                        )?;
                        match self.handle_udx_edxf_packing_units(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UdxEdxfProductLogisticDetails(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.PRODUCT_LOGISTIC_DETAILS",
                            false,
                        )?;
                        match self.handle_udx_edxf_product_logistic_details(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfReach(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.REACH",
                            false,
                        )?;
                        match self.handle_udx_edxf_reach(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UdxEdxfSurchargeList(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.SURCHARGE_LIST",
                            false,
                        )?;
                        match self.handle_udx_edxf_surcharge_list(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(mut self, helper: &mut DeserializeHelper) -> Result<super::UdxProduct, Error> {
            let state = replace(&mut *self.state__, UdxProductDeserializerState::Unknown__);
            self.finish_state(helper, state)?;
            Ok(super::UdxProduct {
                udx_edxf_manufacturer_acronym: self.udx_edxf_manufacturer_acronym,
                udx_edxf_description_very_short: self.udx_edxf_description_very_short,
                udx_edxf_brand_name: self.udx_edxf_brand_name,
                udx_edxf_tender_text: self.udx_edxf_tender_text,
                udx_edxf_valid_from: self.udx_edxf_valid_from,
                udx_edxf_expiration_date: self.udx_edxf_expiration_date,
                udx_edxf_discount_group: self.udx_edxf_discount_group,
                udx_edxf_bonus_group_supplier: self.udx_edxf_bonus_group_supplier,
                udx_edxf_pkwiu: self.udx_edxf_pkwiu,
                udx_edxf_declaration: self.udx_edxf_declaration,
                udx_edxf_additional_factors: self.udx_edxf_additional_factors,
                udx_edxf_product_to_stock: self.udx_edxf_product_to_stock,
                udx_edxf_product_series: self.udx_edxf_product_series,
                udx_edxf_product_variation: self.udx_edxf_product_variation,
                udx_edxf_at_reverse_charge_info: self.udx_edxf_at_reverse_charge_info,
                udx_edxf_country_branch_numbers: self.udx_edxf_country_branch_numbers,
                udx_edxf_country_branch_supplier_ids: self.udx_edxf_country_branch_supplier_ids,
                udx_edxf_packing_units: self.udx_edxf_packing_units,
                udx_edxf_product_logistic_details: self.udx_edxf_product_logistic_details,
                udx_edxf_reach: self.udx_edxf_reach,
                udx_edxf_surcharge_list: self.udx_edxf_surcharge_list,
            })
        }
    }
    #[derive(Debug)]
    pub struct ProductReferenceElementTypeDeserializer {
        type_: super::ProductReferenceType,
        quantity: Option<i32>,
        prod_id_to: Option<String>,
        catalog_id: Option<String>,
        catalog_version: Option<String>,
        state__: Box<ProductReferenceElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum ProductReferenceElementTypeDeserializerState {
        Init__,
        ProdIdTo(Option<<String as WithDeserializer>::Deserializer>),
        CatalogId(Option<<String as WithDeserializer>::Deserializer>),
        CatalogVersion(Option<<String as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl ProductReferenceElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut type_: Option<super::ProductReferenceType> = None;
            let mut quantity: Option<i32> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"type")
                ) {
                    helper.read_attrib(&mut type_, b"type", &attrib.value)?;
                } else if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"quantity")
                ) {
                    helper.read_attrib(&mut quantity, b"quantity", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                type_: type_.ok_or_else(|| ErrorKind::MissingAttribute("type".into()))?,
                quantity: quantity,
                prod_id_to: None,
                catalog_id: None,
                catalog_version: None,
                state__: Box::new(ProductReferenceElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: ProductReferenceElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use ProductReferenceElementTypeDeserializerState as S;
            match state {
                S::ProdIdTo(Some(deserializer)) => {
                    self.store_prod_id_to(deserializer.finish(helper)?)?
                }
                S::CatalogId(Some(deserializer)) => {
                    self.store_catalog_id(deserializer.finish(helper)?)?
                }
                S::CatalogVersion(Some(deserializer)) => {
                    self.store_catalog_version(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_prod_id_to(&mut self, value: String) -> Result<(), Error> {
            if self.prod_id_to.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"PROD_ID_TO",
                )))?;
            }
            self.prod_id_to = Some(value);
            Ok(())
        }
        fn store_catalog_id(&mut self, value: String) -> Result<(), Error> {
            if self.catalog_id.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"CATALOG_ID",
                )))?;
            }
            self.catalog_id = Some(value);
            Ok(())
        }
        fn store_catalog_version(&mut self, value: String) -> Result<(), Error> {
            if self.catalog_version.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"CATALOG_VERSION",
                )))?;
            }
            self.catalog_version = Some(value);
            Ok(())
        }
        fn handle_prod_id_to<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<ProductReferenceElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductReferenceElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::ProdIdTo(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_prod_id_to(data)?;
                    *self.state__ = S::CatalogId(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::ProdIdTo(Some(deserializer)));
                    *self.state__ = S::CatalogId(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_catalog_id<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<ProductReferenceElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductReferenceElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::CatalogVersion(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_catalog_id(data)?;
                    *self.state__ = S::CatalogVersion(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::CatalogId(Some(deserializer)));
                    *self.state__ = S::CatalogVersion(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_catalog_version<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<ProductReferenceElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductReferenceElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Done__;
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_catalog_version(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::CatalogVersion(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::ProductReferenceElementType>
        for ProductReferenceElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductReferenceElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductReferenceElementType> {
            use ProductReferenceElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::ProdIdTo(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_prod_id_to(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::CatalogId(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_catalog_id(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::CatalogVersion(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_catalog_version(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::ProdIdTo(None);
                        event
                    }
                    (S::ProdIdTo(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PROD_ID_TO",
                            false,
                        )?;
                        match self.handle_prod_id_to(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::CatalogId(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"CATALOG_ID",
                            false,
                        )?;
                        match self.handle_catalog_id(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::CatalogVersion(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"CATALOG_VERSION",
                            false,
                        )?;
                        match self.handle_catalog_version(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::ProductReferenceElementType, Error> {
            let state = replace(
                &mut *self.state__,
                ProductReferenceElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::ProductReferenceElementType {
                type_: self.type_,
                quantity: self.quantity,
                prod_id_to: helper.finish_element("PROD_ID_TO", self.prod_id_to)?,
                catalog_id: self.catalog_id,
                catalog_version: self.catalog_version,
            })
        }
    }
    #[derive(Debug)]
    pub struct ProductLogisticDetailsElementTypeDeserializer {
        customs_tariff_number: Vec<super::CustomsTariffNumberElementType>,
        statistics_factor: Option<f64>,
        country_of_origin: Vec<String>,
        state__: Box<ProductLogisticDetailsElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum ProductLogisticDetailsElementTypeDeserializerState {
        Init__,
        CustomsTariffNumber(
            Option<<super::CustomsTariffNumberElementType as WithDeserializer>::Deserializer>,
        ),
        StatisticsFactor(Option<<f64 as WithDeserializer>::Deserializer>),
        CountryOfOrigin(Option<<String as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl ProductLogisticDetailsElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                customs_tariff_number: Vec::new(),
                statistics_factor: None,
                country_of_origin: Vec::new(),
                state__: Box::new(ProductLogisticDetailsElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: ProductLogisticDetailsElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use ProductLogisticDetailsElementTypeDeserializerState as S;
            match state {
                S::CustomsTariffNumber(Some(deserializer)) => {
                    self.store_customs_tariff_number(deserializer.finish(helper)?)?
                }
                S::StatisticsFactor(Some(deserializer)) => {
                    self.store_statistics_factor(deserializer.finish(helper)?)?
                }
                S::CountryOfOrigin(Some(deserializer)) => {
                    self.store_country_of_origin(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_customs_tariff_number(
            &mut self,
            value: super::CustomsTariffNumberElementType,
        ) -> Result<(), Error> {
            self.customs_tariff_number.push(value);
            Ok(())
        }
        fn store_statistics_factor(&mut self, value: f64) -> Result<(), Error> {
            if self.statistics_factor.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"STATISTICS_FACTOR",
                )))?;
            }
            self.statistics_factor = Some(value);
            Ok(())
        }
        fn store_country_of_origin(&mut self, value: String) -> Result<(), Error> {
            self.country_of_origin.push(value);
            Ok(())
        }
        fn handle_customs_tariff_number<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::CustomsTariffNumberElementType>,
            fallback: &mut Option<ProductLogisticDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductLogisticDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::StatisticsFactor(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_customs_tariff_number(data)?;
                    *self.state__ = S::CustomsTariffNumber(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::CustomsTariffNumber(Some(deserializer)));
                    *self.state__ = S::CustomsTariffNumber(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_statistics_factor<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f64>,
            fallback: &mut Option<ProductLogisticDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductLogisticDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::CountryOfOrigin(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_statistics_factor(data)?;
                    *self.state__ = S::CountryOfOrigin(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::StatisticsFactor(Some(deserializer)));
                    *self.state__ = S::CountryOfOrigin(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_country_of_origin<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<ProductLogisticDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductLogisticDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Done__;
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_country_of_origin(data)?;
                    *self.state__ = S::CountryOfOrigin(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::CountryOfOrigin(Some(deserializer)));
                    *self.state__ = S::CountryOfOrigin(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::ProductLogisticDetailsElementType>
        for ProductLogisticDetailsElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductLogisticDetailsElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductLogisticDetailsElementType> {
            use ProductLogisticDetailsElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::CustomsTariffNumber(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_customs_tariff_number(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::StatisticsFactor(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_statistics_factor(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::CountryOfOrigin(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_country_of_origin(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::CustomsTariffNumber(None);
                        event
                    }
                    (S::CustomsTariffNumber(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"CUSTOMS_TARIFF_NUMBER",
                            false,
                        )?;
                        match self.handle_customs_tariff_number(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::StatisticsFactor(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"STATISTICS_FACTOR",
                            false,
                        )?;
                        match self.handle_statistics_factor(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::CountryOfOrigin(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"COUNTRY_OF_ORIGIN",
                            false,
                        )?;
                        match self.handle_country_of_origin(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::ProductLogisticDetailsElementType, Error> {
            let state = replace(
                &mut *self.state__,
                ProductLogisticDetailsElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::ProductLogisticDetailsElementType {
                customs_tariff_number: self.customs_tariff_number,
                statistics_factor: self.statistics_factor,
                country_of_origin: self.country_of_origin,
            })
        }
    }
    #[derive(Debug)]
    pub struct MimeElementTypeDeserializer {
        mime_type: Option<String>,
        mime_source: Vec<super::DtMlstring>,
        mime_descr: Vec<super::DtMlstring>,
        mime_alt: Vec<super::DtMlstring>,
        mime_purpose: Option<super::MimePurposeElementType>,
        state__: Box<MimeElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum MimeElementTypeDeserializerState {
        Init__,
        MimeType(Option<<String as WithDeserializer>::Deserializer>),
        MimeSource(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        MimeDescr(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        MimeAlt(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        MimePurpose(Option<<super::MimePurposeElementType as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl MimeElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                mime_type: None,
                mime_source: Vec::new(),
                mime_descr: Vec::new(),
                mime_alt: Vec::new(),
                mime_purpose: None,
                state__: Box::new(MimeElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: MimeElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use MimeElementTypeDeserializerState as S;
            match state {
                S::MimeType(Some(deserializer)) => {
                    self.store_mime_type(deserializer.finish(helper)?)?
                }
                S::MimeSource(Some(deserializer)) => {
                    self.store_mime_source(deserializer.finish(helper)?)?
                }
                S::MimeDescr(Some(deserializer)) => {
                    self.store_mime_descr(deserializer.finish(helper)?)?
                }
                S::MimeAlt(Some(deserializer)) => {
                    self.store_mime_alt(deserializer.finish(helper)?)?
                }
                S::MimePurpose(Some(deserializer)) => {
                    self.store_mime_purpose(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_mime_type(&mut self, value: String) -> Result<(), Error> {
            if self.mime_type.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"MIME_TYPE",
                )))?;
            }
            self.mime_type = Some(value);
            Ok(())
        }
        fn store_mime_source(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.mime_source.push(value);
            Ok(())
        }
        fn store_mime_descr(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.mime_descr.push(value);
            Ok(())
        }
        fn store_mime_alt(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.mime_alt.push(value);
            Ok(())
        }
        fn store_mime_purpose(
            &mut self,
            value: super::MimePurposeElementType,
        ) -> Result<(), Error> {
            if self.mime_purpose.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"MIME_PURPOSE",
                )))?;
            }
            self.mime_purpose = Some(value);
            Ok(())
        }
        fn handle_mime_type<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<MimeElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use MimeElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::MimeType(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_mime_type(data)?;
                    *self.state__ = S::MimeSource(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::MimeType(Some(deserializer)));
                    *self.state__ = S::MimeSource(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_mime_source<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<MimeElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use MimeElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.mime_source.len() < 1usize {
                    fallback.get_or_insert(S::MimeSource(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::MimeDescr(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_mime_source(data)?;
                    *self.state__ = S::MimeSource(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::MimeSource(Some(deserializer)));
                    *self.state__ = S::MimeSource(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_mime_descr<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<MimeElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use MimeElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::MimeAlt(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_mime_descr(data)?;
                    *self.state__ = S::MimeDescr(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::MimeDescr(Some(deserializer)));
                    *self.state__ = S::MimeDescr(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_mime_alt<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<MimeElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use MimeElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::MimePurpose(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_mime_alt(data)?;
                    *self.state__ = S::MimeAlt(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::MimeAlt(Some(deserializer)));
                    *self.state__ = S::MimeAlt(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_mime_purpose<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::MimePurposeElementType>,
            fallback: &mut Option<MimeElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use MimeElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::MimePurpose(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_mime_purpose(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::MimePurpose(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::MimeElementType> for MimeElementTypeDeserializer {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::MimeElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::MimeElementType> {
            use MimeElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::MimeType(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_mime_type(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::MimeSource(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_mime_source(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::MimeDescr(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_mime_descr(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::MimeAlt(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_mime_alt(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::MimePurpose(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_mime_purpose(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::MimeType(None);
                        event
                    }
                    (S::MimeType(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"MIME_TYPE",
                            false,
                        )?;
                        match self.handle_mime_type(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::MimeSource(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"MIME_SOURCE",
                            false,
                        )?;
                        match self.handle_mime_source(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::MimeDescr(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"MIME_DESCR",
                            false,
                        )?;
                        match self.handle_mime_descr(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::MimeAlt(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"MIME_ALT",
                            false,
                        )?;
                        match self.handle_mime_alt(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::MimePurpose(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"MIME_PURPOSE",
                            false,
                        )?;
                        match self.handle_mime_purpose(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::MimeElementType, Error> {
            let state = replace(
                &mut *self.state__,
                MimeElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::MimeElementType {
                mime_type: helper.finish_element("MIME_TYPE", self.mime_type)?,
                mime_source: helper.finish_vec(1usize, None, self.mime_source)?,
                mime_descr: self.mime_descr,
                mime_alt: self.mime_alt,
                mime_purpose: helper.finish_element("MIME_PURPOSE", self.mime_purpose)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct InternationalPidElementTypeDeserializer {
        type_: Option<String>,
        content: Option<String>,
        state__: Box<InternationalPidElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum InternationalPidElementTypeDeserializerState {
        Init__,
        Content__(<String as WithDeserializer>::Deserializer),
        Unknown__,
    }
    impl InternationalPidElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut type_: Option<String> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"type")
                ) {
                    helper.read_attrib(&mut type_, b"type", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                type_: type_,
                content: None,
                state__: Box::new(InternationalPidElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: InternationalPidElementTypeDeserializerState,
        ) -> Result<(), Error> {
            if let InternationalPidElementTypeDeserializerState::Content__(deserializer) = state {
                self.store_content(deserializer.finish(helper)?)?;
            }
            Ok(())
        }
        fn store_content(&mut self, value: String) -> Result<(), Error> {
            if self.content.is_some() {
                Err(ErrorKind::DuplicateContent)?;
            }
            self.content = Some(value);
            Ok(())
        }
        fn handle_content<'de>(
            mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
        ) -> DeserializerResult<'de, super::InternationalPidElementType> {
            use InternationalPidElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            match artifact {
                DeserializerArtifact::None => Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event,
                    allow_any,
                }),
                DeserializerArtifact::Data(data) => {
                    self.store_content(data)?;
                    let data = self.finish(helper)?;
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(data),
                        event,
                        allow_any,
                    })
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::Content__(deserializer);
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event,
                        allow_any,
                    })
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::InternationalPidElementType>
        for InternationalPidElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::InternationalPidElementType> {
            let (Event::Start(x) | Event::Empty(x)) = &event else {
                return Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event: DeserializerEvent::Break(event),
                    allow_any: false,
                });
            };
            Self::from_bytes_start(helper, x)?.next(helper, event)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::InternationalPidElementType> {
            use InternationalPidElementTypeDeserializerState as S;
            match replace(&mut *self.state__, S::Unknown__) {
                S::Unknown__ => unreachable!(),
                S::Init__ => {
                    let output = ContentDeserializer::init(helper, event)?;
                    self.handle_content(helper, output)
                }
                S::Content__(deserializer) => {
                    let output = deserializer.next(helper, event)?;
                    self.handle_content(helper, output)
                }
            }
        }
        fn finish(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::InternationalPidElementType, Error> {
            let state = replace(
                &mut *self.state__,
                InternationalPidElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::InternationalPidElementType {
                type_: self.type_,
                content: helper.finish_content(self.content)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct BuyerPidElementTypeDeserializer {
        type_: Option<String>,
        content: Option<String>,
        state__: Box<BuyerPidElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum BuyerPidElementTypeDeserializerState {
        Init__,
        Content__(<String as WithDeserializer>::Deserializer),
        Unknown__,
    }
    impl BuyerPidElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut type_: Option<String> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"type")
                ) {
                    helper.read_attrib(&mut type_, b"type", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                type_: type_,
                content: None,
                state__: Box::new(BuyerPidElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: BuyerPidElementTypeDeserializerState,
        ) -> Result<(), Error> {
            if let BuyerPidElementTypeDeserializerState::Content__(deserializer) = state {
                self.store_content(deserializer.finish(helper)?)?;
            }
            Ok(())
        }
        fn store_content(&mut self, value: String) -> Result<(), Error> {
            if self.content.is_some() {
                Err(ErrorKind::DuplicateContent)?;
            }
            self.content = Some(value);
            Ok(())
        }
        fn handle_content<'de>(
            mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
        ) -> DeserializerResult<'de, super::BuyerPidElementType> {
            use BuyerPidElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            match artifact {
                DeserializerArtifact::None => Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event,
                    allow_any,
                }),
                DeserializerArtifact::Data(data) => {
                    self.store_content(data)?;
                    let data = self.finish(helper)?;
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(data),
                        event,
                        allow_any,
                    })
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::Content__(deserializer);
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event,
                        allow_any,
                    })
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::BuyerPidElementType> for BuyerPidElementTypeDeserializer {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::BuyerPidElementType> {
            let (Event::Start(x) | Event::Empty(x)) = &event else {
                return Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event: DeserializerEvent::Break(event),
                    allow_any: false,
                });
            };
            Self::from_bytes_start(helper, x)?.next(helper, event)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::BuyerPidElementType> {
            use BuyerPidElementTypeDeserializerState as S;
            match replace(&mut *self.state__, S::Unknown__) {
                S::Unknown__ => unreachable!(),
                S::Init__ => {
                    let output = ContentDeserializer::init(helper, event)?;
                    self.handle_content(helper, output)
                }
                S::Content__(deserializer) => {
                    let output = deserializer.next(helper, event)?;
                    self.handle_content(helper, output)
                }
            }
        }
        fn finish(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::BuyerPidElementType, Error> {
            let state = replace(
                &mut *self.state__,
                BuyerPidElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::BuyerPidElementType {
                type_: self.type_,
                content: helper.finish_content(self.content)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct SpecialTreatmentClassElementTypeDeserializer {
        type_: String,
        content: Option<String>,
        state__: Box<SpecialTreatmentClassElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum SpecialTreatmentClassElementTypeDeserializerState {
        Init__,
        Content__(<String as WithDeserializer>::Deserializer),
        Unknown__,
    }
    impl SpecialTreatmentClassElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut type_: Option<String> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"type")
                ) {
                    helper.read_attrib(&mut type_, b"type", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                type_: type_.ok_or_else(|| ErrorKind::MissingAttribute("type".into()))?,
                content: None,
                state__: Box::new(SpecialTreatmentClassElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: SpecialTreatmentClassElementTypeDeserializerState,
        ) -> Result<(), Error> {
            if let SpecialTreatmentClassElementTypeDeserializerState::Content__(deserializer) =
                state
            {
                self.store_content(deserializer.finish(helper)?)?;
            }
            Ok(())
        }
        fn store_content(&mut self, value: String) -> Result<(), Error> {
            if self.content.is_some() {
                Err(ErrorKind::DuplicateContent)?;
            }
            self.content = Some(value);
            Ok(())
        }
        fn handle_content<'de>(
            mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
        ) -> DeserializerResult<'de, super::SpecialTreatmentClassElementType> {
            use SpecialTreatmentClassElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            match artifact {
                DeserializerArtifact::None => Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event,
                    allow_any,
                }),
                DeserializerArtifact::Data(data) => {
                    self.store_content(data)?;
                    let data = self.finish(helper)?;
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(data),
                        event,
                        allow_any,
                    })
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::Content__(deserializer);
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event,
                        allow_any,
                    })
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::SpecialTreatmentClassElementType>
        for SpecialTreatmentClassElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::SpecialTreatmentClassElementType> {
            let (Event::Start(x) | Event::Empty(x)) = &event else {
                return Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event: DeserializerEvent::Break(event),
                    allow_any: false,
                });
            };
            Self::from_bytes_start(helper, x)?.next(helper, event)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::SpecialTreatmentClassElementType> {
            use SpecialTreatmentClassElementTypeDeserializerState as S;
            match replace(&mut *self.state__, S::Unknown__) {
                S::Unknown__ => unreachable!(),
                S::Init__ => {
                    let output = ContentDeserializer::init(helper, event)?;
                    self.handle_content(helper, output)
                }
                S::Content__(deserializer) => {
                    let output = deserializer.next(helper, event)?;
                    self.handle_content(helper, output)
                }
            }
        }
        fn finish(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::SpecialTreatmentClassElementType, Error> {
            let state = replace(
                &mut *self.state__,
                SpecialTreatmentClassElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::SpecialTreatmentClassElementType {
                type_: self.type_,
                content: helper.finish_content(self.content)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct RemarksElementTypeDeserializer {
        lang: Option<super::DtLang>,
        type_: Option<String>,
        content: Option<String>,
        state__: Box<RemarksElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum RemarksElementTypeDeserializerState {
        Init__,
        Content__(<String as WithDeserializer>::Deserializer),
        Unknown__,
    }
    impl RemarksElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut lang: Option<super::DtLang> = None;
            let mut type_: Option<String> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"lang")
                ) {
                    helper.read_attrib(&mut lang, b"lang", &attrib.value)?;
                } else if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"type")
                ) {
                    helper.read_attrib(&mut type_, b"type", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                lang: lang,
                type_: type_,
                content: None,
                state__: Box::new(RemarksElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: RemarksElementTypeDeserializerState,
        ) -> Result<(), Error> {
            if let RemarksElementTypeDeserializerState::Content__(deserializer) = state {
                self.store_content(deserializer.finish(helper)?)?;
            }
            Ok(())
        }
        fn store_content(&mut self, value: String) -> Result<(), Error> {
            if self.content.is_some() {
                Err(ErrorKind::DuplicateContent)?;
            }
            self.content = Some(value);
            Ok(())
        }
        fn handle_content<'de>(
            mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
        ) -> DeserializerResult<'de, super::RemarksElementType> {
            use RemarksElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            match artifact {
                DeserializerArtifact::None => Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event,
                    allow_any,
                }),
                DeserializerArtifact::Data(data) => {
                    self.store_content(data)?;
                    let data = self.finish(helper)?;
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(data),
                        event,
                        allow_any,
                    })
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::Content__(deserializer);
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event,
                        allow_any,
                    })
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::RemarksElementType> for RemarksElementTypeDeserializer {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::RemarksElementType> {
            let (Event::Start(x) | Event::Empty(x)) = &event else {
                return Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event: DeserializerEvent::Break(event),
                    allow_any: false,
                });
            };
            Self::from_bytes_start(helper, x)?.next(helper, event)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::RemarksElementType> {
            use RemarksElementTypeDeserializerState as S;
            match replace(&mut *self.state__, S::Unknown__) {
                S::Unknown__ => unreachable!(),
                S::Init__ => {
                    let output = ContentDeserializer::init(helper, event)?;
                    self.handle_content(helper, output)
                }
                S::Content__(deserializer) => {
                    let output = deserializer.next(helper, event)?;
                    self.handle_content(helper, output)
                }
            }
        }
        fn finish(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::RemarksElementType, Error> {
            let state = replace(
                &mut *self.state__,
                RemarksElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::RemarksElementType {
                lang: self.lang,
                type_: self.type_,
                content: helper.finish_content(self.content)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct ProductStatusElementTypeDeserializer {
        lang: Option<super::DtLang>,
        type_: super::ProductStatusType,
        content: Option<String>,
        state__: Box<ProductStatusElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum ProductStatusElementTypeDeserializerState {
        Init__,
        Content__(<String as WithDeserializer>::Deserializer),
        Unknown__,
    }
    impl ProductStatusElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut lang: Option<super::DtLang> = None;
            let mut type_: Option<super::ProductStatusType> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"lang")
                ) {
                    helper.read_attrib(&mut lang, b"lang", &attrib.value)?;
                } else if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"type")
                ) {
                    helper.read_attrib(&mut type_, b"type", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                lang: lang,
                type_: type_.ok_or_else(|| ErrorKind::MissingAttribute("type".into()))?,
                content: None,
                state__: Box::new(ProductStatusElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: ProductStatusElementTypeDeserializerState,
        ) -> Result<(), Error> {
            if let ProductStatusElementTypeDeserializerState::Content__(deserializer) = state {
                self.store_content(deserializer.finish(helper)?)?;
            }
            Ok(())
        }
        fn store_content(&mut self, value: String) -> Result<(), Error> {
            if self.content.is_some() {
                Err(ErrorKind::DuplicateContent)?;
            }
            self.content = Some(value);
            Ok(())
        }
        fn handle_content<'de>(
            mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
        ) -> DeserializerResult<'de, super::ProductStatusElementType> {
            use ProductStatusElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            match artifact {
                DeserializerArtifact::None => Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event,
                    allow_any,
                }),
                DeserializerArtifact::Data(data) => {
                    self.store_content(data)?;
                    let data = self.finish(helper)?;
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(data),
                        event,
                        allow_any,
                    })
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::Content__(deserializer);
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event,
                        allow_any,
                    })
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::ProductStatusElementType>
        for ProductStatusElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductStatusElementType> {
            let (Event::Start(x) | Event::Empty(x)) = &event else {
                return Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event: DeserializerEvent::Break(event),
                    allow_any: false,
                });
            };
            Self::from_bytes_start(helper, x)?.next(helper, event)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductStatusElementType> {
            use ProductStatusElementTypeDeserializerState as S;
            match replace(&mut *self.state__, S::Unknown__) {
                S::Unknown__ => unreachable!(),
                S::Init__ => {
                    let output = ContentDeserializer::init(helper, event)?;
                    self.handle_content(helper, output)
                }
                S::Content__(deserializer) => {
                    let output = deserializer.next(helper, event)?;
                    self.handle_content(helper, output)
                }
            }
        }
        fn finish(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::ProductStatusElementType, Error> {
            let state = replace(
                &mut *self.state__,
                ProductStatusElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::ProductStatusElementType {
                lang: self.lang,
                type_: self.type_,
                content: helper.finish_content(self.content)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct TypeClassificationGroupIdDeserializer {
        type_: Option<super::TypeClassificationGroupIdType>,
        content: Option<String>,
        state__: Box<TypeClassificationGroupIdDeserializerState>,
    }
    #[derive(Debug)]
    enum TypeClassificationGroupIdDeserializerState {
        Init__,
        Content__(<String as WithDeserializer>::Deserializer),
        Unknown__,
    }
    impl TypeClassificationGroupIdDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut type_: Option<super::TypeClassificationGroupIdType> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"type")
                ) {
                    helper.read_attrib(&mut type_, b"type", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                type_: type_,
                content: None,
                state__: Box::new(TypeClassificationGroupIdDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: TypeClassificationGroupIdDeserializerState,
        ) -> Result<(), Error> {
            if let TypeClassificationGroupIdDeserializerState::Content__(deserializer) = state {
                self.store_content(deserializer.finish(helper)?)?;
            }
            Ok(())
        }
        fn store_content(&mut self, value: String) -> Result<(), Error> {
            if self.content.is_some() {
                Err(ErrorKind::DuplicateContent)?;
            }
            self.content = Some(value);
            Ok(())
        }
        fn handle_content<'de>(
            mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
        ) -> DeserializerResult<'de, super::TypeClassificationGroupId> {
            use TypeClassificationGroupIdDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            match artifact {
                DeserializerArtifact::None => Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event,
                    allow_any,
                }),
                DeserializerArtifact::Data(data) => {
                    self.store_content(data)?;
                    let data = self.finish(helper)?;
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(data),
                        event,
                        allow_any,
                    })
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::Content__(deserializer);
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event,
                        allow_any,
                    })
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::TypeClassificationGroupId>
        for TypeClassificationGroupIdDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::TypeClassificationGroupId> {
            let (Event::Start(x) | Event::Empty(x)) = &event else {
                return Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event: DeserializerEvent::Break(event),
                    allow_any: false,
                });
            };
            Self::from_bytes_start(helper, x)?.next(helper, event)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::TypeClassificationGroupId> {
            use TypeClassificationGroupIdDeserializerState as S;
            match replace(&mut *self.state__, S::Unknown__) {
                S::Unknown__ => unreachable!(),
                S::Init__ => {
                    let output = ContentDeserializer::init(helper, event)?;
                    self.handle_content(helper, output)
                }
                S::Content__(deserializer) => {
                    let output = deserializer.next(helper, event)?;
                    self.handle_content(helper, output)
                }
            }
        }
        fn finish(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::TypeClassificationGroupId, Error> {
            let state = replace(
                &mut *self.state__,
                TypeClassificationGroupIdDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::TypeClassificationGroupId {
                type_: self.type_,
                content: helper.finish_content(self.content)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct FeatureElementTypeDeserializer {
        fname: Vec<super::DtMlstring>,
        fvalue: Vec<super::DtMlstring>,
        funit: Option<String>,
        fvalue_details: Vec<super::DtMlstring>,
        state__: Box<FeatureElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum FeatureElementTypeDeserializerState {
        Init__,
        Fname(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        Fvalue(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        Funit(Option<<String as WithDeserializer>::Deserializer>),
        FvalueDetails(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl FeatureElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                fname: Vec::new(),
                fvalue: Vec::new(),
                funit: None,
                fvalue_details: Vec::new(),
                state__: Box::new(FeatureElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: FeatureElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use FeatureElementTypeDeserializerState as S;
            match state {
                S::Fname(Some(deserializer)) => self.store_fname(deserializer.finish(helper)?)?,
                S::Fvalue(Some(deserializer)) => self.store_fvalue(deserializer.finish(helper)?)?,
                S::Funit(Some(deserializer)) => self.store_funit(deserializer.finish(helper)?)?,
                S::FvalueDetails(Some(deserializer)) => {
                    self.store_fvalue_details(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_fname(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.fname.push(value);
            Ok(())
        }
        fn store_fvalue(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.fvalue.push(value);
            Ok(())
        }
        fn store_funit(&mut self, value: String) -> Result<(), Error> {
            if self.funit.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"FUNIT",
                )))?;
            }
            self.funit = Some(value);
            Ok(())
        }
        fn store_fvalue_details(&mut self, value: super::DtMlstring) -> Result<(), Error> {
            self.fvalue_details.push(value);
            Ok(())
        }
        fn handle_fname<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<FeatureElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use FeatureElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.fname.len() < 1usize {
                    fallback.get_or_insert(S::Fname(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::Fvalue(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_fname(data)?;
                    *self.state__ = S::Fname(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Fname(Some(deserializer)));
                    *self.state__ = S::Fname(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_fvalue<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<FeatureElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use FeatureElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.fvalue.len() < 1usize {
                    fallback.get_or_insert(S::Fvalue(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::Funit(None);
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_fvalue(data)?;
                    *self.state__ = S::Fvalue(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Fvalue(Some(deserializer)));
                    *self.state__ = S::Fvalue(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_funit<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<FeatureElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use FeatureElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::FvalueDetails(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_funit(data)?;
                    *self.state__ = S::FvalueDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Funit(Some(deserializer)));
                    *self.state__ = S::FvalueDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_fvalue_details<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<FeatureElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use FeatureElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Done__;
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_fvalue_details(data)?;
                    *self.state__ = S::FvalueDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::FvalueDetails(Some(deserializer)));
                    *self.state__ = S::FvalueDetails(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::FeatureElementType> for FeatureElementTypeDeserializer {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::FeatureElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::FeatureElementType> {
            use FeatureElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::Fname(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_fname(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Fvalue(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_fvalue(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Funit(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_funit(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::FvalueDetails(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_fvalue_details(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::Fname(None);
                        event
                    }
                    (S::Fname(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"FNAME",
                            false,
                        )?;
                        match self.handle_fname(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Fvalue(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"FVALUE",
                            false,
                        )?;
                        match self.handle_fvalue(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Funit(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"FUNIT",
                            false,
                        )?;
                        match self.handle_funit(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::FvalueDetails(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"FVALUE_DETAILS",
                            false,
                        )?;
                        match self.handle_fvalue_details(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::FeatureElementType, Error> {
            let state = replace(
                &mut *self.state__,
                FeatureElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::FeatureElementType {
                fname: helper.finish_vec(1usize, None, self.fname)?,
                fvalue: helper.finish_vec(1usize, None, self.fvalue)?,
                funit: self.funit,
                fvalue_details: self.fvalue_details,
            })
        }
    }
    #[derive(Debug)]
    pub struct ProductPriceDetailsDatetimeElementTypeDeserializer {
        type_: super::ProductPriceDetailsDatetimeType,
        date: Option<String>,
        time: Option<String>,
        timezone: Option<String>,
        state__: Box<ProductPriceDetailsDatetimeElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum ProductPriceDetailsDatetimeElementTypeDeserializerState {
        Init__,
        Date(Option<<String as WithDeserializer>::Deserializer>),
        Time(Option<<String as WithDeserializer>::Deserializer>),
        Timezone(Option<<String as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl ProductPriceDetailsDatetimeElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut type_: Option<super::ProductPriceDetailsDatetimeType> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"type")
                ) {
                    helper.read_attrib(&mut type_, b"type", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                type_: type_.ok_or_else(|| ErrorKind::MissingAttribute("type".into()))?,
                date: None,
                time: None,
                timezone: None,
                state__: Box::new(ProductPriceDetailsDatetimeElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: ProductPriceDetailsDatetimeElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use ProductPriceDetailsDatetimeElementTypeDeserializerState as S;
            match state {
                S::Date(Some(deserializer)) => self.store_date(deserializer.finish(helper)?)?,
                S::Time(Some(deserializer)) => self.store_time(deserializer.finish(helper)?)?,
                S::Timezone(Some(deserializer)) => {
                    self.store_timezone(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_date(&mut self, value: String) -> Result<(), Error> {
            if self.date.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"DATE")))?;
            }
            self.date = Some(value);
            Ok(())
        }
        fn store_time(&mut self, value: String) -> Result<(), Error> {
            if self.time.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"TIME")))?;
            }
            self.time = Some(value);
            Ok(())
        }
        fn store_timezone(&mut self, value: String) -> Result<(), Error> {
            if self.timezone.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"TIMEZONE",
                )))?;
            }
            self.timezone = Some(value);
            Ok(())
        }
        fn handle_date<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<ProductPriceDetailsDatetimeElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductPriceDetailsDatetimeElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::Date(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_date(data)?;
                    *self.state__ = S::Time(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Date(Some(deserializer)));
                    *self.state__ = S::Time(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_time<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<ProductPriceDetailsDatetimeElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductPriceDetailsDatetimeElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Timezone(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_time(data)?;
                    *self.state__ = S::Timezone(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Time(Some(deserializer)));
                    *self.state__ = S::Timezone(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_timezone<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<ProductPriceDetailsDatetimeElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductPriceDetailsDatetimeElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Done__;
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_timezone(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Timezone(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::ProductPriceDetailsDatetimeElementType>
        for ProductPriceDetailsDatetimeElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductPriceDetailsDatetimeElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductPriceDetailsDatetimeElementType> {
            use ProductPriceDetailsDatetimeElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::Date(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_date(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Time(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_time(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Timezone(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_timezone(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::Date(None);
                        event
                    }
                    (S::Date(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"DATE",
                            false,
                        )?;
                        match self.handle_date(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Time(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"TIME",
                            false,
                        )?;
                        match self.handle_time(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Timezone(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"TIMEZONE",
                            false,
                        )?;
                        match self.handle_timezone(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::ProductPriceDetailsDatetimeElementType, Error> {
            let state = replace(
                &mut *self.state__,
                ProductPriceDetailsDatetimeElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::ProductPriceDetailsDatetimeElementType {
                type_: self.type_,
                date: helper.finish_element("DATE", self.date)?,
                time: self.time,
                timezone: self.timezone,
            })
        }
    }
    #[derive(Debug)]
    pub struct ProductPriceElementTypeDeserializer {
        price_type: String,
        price_amount: Option<f64>,
        price_currency: Option<super::DtCurrencies>,
        tax: Option<f64>,
        price_factor: Option<f64>,
        lower_bound: Option<f64>,
        territory: Vec<String>,
        state__: Box<ProductPriceElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum ProductPriceElementTypeDeserializerState {
        Init__,
        PriceAmount(Option<<f64 as WithDeserializer>::Deserializer>),
        PriceCurrency(Option<<super::DtCurrencies as WithDeserializer>::Deserializer>),
        Tax(Option<<f64 as WithDeserializer>::Deserializer>),
        PriceFactor(Option<<f64 as WithDeserializer>::Deserializer>),
        LowerBound(Option<<f64 as WithDeserializer>::Deserializer>),
        Territory(Option<<String as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl ProductPriceElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut price_type: Option<String> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"price_type")
                ) {
                    helper.read_attrib(&mut price_type, b"price_type", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                price_type: price_type
                    .ok_or_else(|| ErrorKind::MissingAttribute("price_type".into()))?,
                price_amount: None,
                price_currency: None,
                tax: None,
                price_factor: None,
                lower_bound: None,
                territory: Vec::new(),
                state__: Box::new(ProductPriceElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: ProductPriceElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use ProductPriceElementTypeDeserializerState as S;
            match state {
                S::PriceAmount(Some(deserializer)) => {
                    self.store_price_amount(deserializer.finish(helper)?)?
                }
                S::PriceCurrency(Some(deserializer)) => {
                    self.store_price_currency(deserializer.finish(helper)?)?
                }
                S::Tax(Some(deserializer)) => self.store_tax(deserializer.finish(helper)?)?,
                S::PriceFactor(Some(deserializer)) => {
                    self.store_price_factor(deserializer.finish(helper)?)?
                }
                S::LowerBound(Some(deserializer)) => {
                    self.store_lower_bound(deserializer.finish(helper)?)?
                }
                S::Territory(Some(deserializer)) => {
                    self.store_territory(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_price_amount(&mut self, value: f64) -> Result<(), Error> {
            if self.price_amount.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"PRICE_AMOUNT",
                )))?;
            }
            self.price_amount = Some(value);
            Ok(())
        }
        fn store_price_currency(&mut self, value: super::DtCurrencies) -> Result<(), Error> {
            if self.price_currency.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"PRICE_CURRENCY",
                )))?;
            }
            self.price_currency = Some(value);
            Ok(())
        }
        fn store_tax(&mut self, value: f64) -> Result<(), Error> {
            if self.tax.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"TAX")))?;
            }
            self.tax = Some(value);
            Ok(())
        }
        fn store_price_factor(&mut self, value: f64) -> Result<(), Error> {
            if self.price_factor.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"PRICE_FACTOR",
                )))?;
            }
            self.price_factor = Some(value);
            Ok(())
        }
        fn store_lower_bound(&mut self, value: f64) -> Result<(), Error> {
            if self.lower_bound.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"LOWER_BOUND",
                )))?;
            }
            self.lower_bound = Some(value);
            Ok(())
        }
        fn store_territory(&mut self, value: String) -> Result<(), Error> {
            self.territory.push(value);
            Ok(())
        }
        fn handle_price_amount<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f64>,
            fallback: &mut Option<ProductPriceElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductPriceElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::PriceAmount(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_price_amount(data)?;
                    *self.state__ = S::PriceCurrency(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::PriceAmount(Some(deserializer)));
                    *self.state__ = S::PriceCurrency(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_price_currency<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtCurrencies>,
            fallback: &mut Option<ProductPriceElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductPriceElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Tax(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_price_currency(data)?;
                    *self.state__ = S::Tax(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::PriceCurrency(Some(deserializer)));
                    *self.state__ = S::Tax(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_tax<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f64>,
            fallback: &mut Option<ProductPriceElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductPriceElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::PriceFactor(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_tax(data)?;
                    *self.state__ = S::PriceFactor(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Tax(Some(deserializer)));
                    *self.state__ = S::PriceFactor(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_price_factor<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f64>,
            fallback: &mut Option<ProductPriceElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductPriceElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::LowerBound(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_price_factor(data)?;
                    *self.state__ = S::LowerBound(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::PriceFactor(Some(deserializer)));
                    *self.state__ = S::LowerBound(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_lower_bound<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f64>,
            fallback: &mut Option<ProductPriceElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductPriceElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Territory(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_lower_bound(data)?;
                    *self.state__ = S::Territory(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::LowerBound(Some(deserializer)));
                    *self.state__ = S::Territory(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_territory<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<ProductPriceElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use ProductPriceElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Done__;
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_territory(data)?;
                    *self.state__ = S::Territory(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::Territory(Some(deserializer)));
                    *self.state__ = S::Territory(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::ProductPriceElementType>
        for ProductPriceElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductPriceElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::ProductPriceElementType> {
            use ProductPriceElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::PriceAmount(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_price_amount(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::PriceCurrency(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_price_currency(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Tax(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_tax(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::PriceFactor(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_price_factor(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::LowerBound(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_lower_bound(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Territory(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_territory(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::PriceAmount(None);
                        event
                    }
                    (S::PriceAmount(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRICE_AMOUNT",
                            false,
                        )?;
                        match self.handle_price_amount(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::PriceCurrency(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRICE_CURRENCY",
                            false,
                        )?;
                        match self.handle_price_currency(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Tax(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"TAX",
                            false,
                        )?;
                        match self.handle_tax(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::PriceFactor(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"PRICE_FACTOR",
                            false,
                        )?;
                        match self.handle_price_factor(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::LowerBound(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"LOWER_BOUND",
                            false,
                        )?;
                        match self.handle_lower_bound(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::Territory(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"TERRITORY",
                            false,
                        )?;
                        match self.handle_territory(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::ProductPriceElementType, Error> {
            let state = replace(
                &mut *self.state__,
                ProductPriceElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::ProductPriceElementType {
                price_type: self.price_type,
                price_amount: helper.finish_element("PRICE_AMOUNT", self.price_amount)?,
                price_currency: self.price_currency,
                tax: self.tax,
                price_factor: self.price_factor,
                lower_bound: self.lower_bound,
                territory: self.territory,
            })
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfDiscountGroupElementTypeDeserializer {
        content: Vec<super::UdxEdxfDiscountGroupElementTypeContent>,
        state__: Box<UdxEdxfDiscountGroupElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum UdxEdxfDiscountGroupElementTypeDeserializerState {
        Init__,
        Next__,
        Content__(
            <super::UdxEdxfDiscountGroupElementTypeContent as WithDeserializer>::Deserializer,
        ),
        Unknown__,
    }
    impl UdxEdxfDiscountGroupElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                content: Vec::new(),
                state__: Box::new(UdxEdxfDiscountGroupElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: UdxEdxfDiscountGroupElementTypeDeserializerState,
        ) -> Result<(), Error> {
            if let UdxEdxfDiscountGroupElementTypeDeserializerState::Content__(deserializer) = state
            {
                self.store_content(deserializer.finish(helper)?)?;
            }
            Ok(())
        }
        fn store_content(
            &mut self,
            value: super::UdxEdxfDiscountGroupElementTypeContent,
        ) -> Result<(), Error> {
            self.content.push(value);
            Ok(())
        }
        fn handle_content<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::UdxEdxfDiscountGroupElementTypeContent>,
            fallback: &mut Option<UdxEdxfDiscountGroupElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfDiscountGroupElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = fallback.take().unwrap_or(S::Next__);
                return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_content(data)?;
                    *self.state__ = S::Next__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    if self.content.len() < 1usize {
                        *fallback = Some(S::Content__(deserializer));
                        *self.state__ = S::Next__;
                        Ok(ElementHandlerOutput::from_event(event, allow_any))
                    } else {
                        *self.state__ = S::Content__(deserializer);
                        Ok(ElementHandlerOutput::from_event_end(event, allow_any))
                    }
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::UdxEdxfDiscountGroupElementType>
        for UdxEdxfDiscountGroupElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfDiscountGroupElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfDiscountGroupElementType> {
            use UdxEdxfDiscountGroupElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::Content__(deserializer), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_content(helper, 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(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (state @ (S::Init__ | S::Next__), event) => {
                        fallback.get_or_insert(state);
                        let output = < super :: UdxEdxfDiscountGroupElementTypeContent as WithDeserializer > :: init (helper , event) ? ;
                        match self.handle_content(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                }
            };
            if let Some(fallback) = fallback {
                *self.state__ = fallback;
            }
            let artifact = DeserializerArtifact::Deserializer(self);
            Ok(DeserializerOutput {
                artifact,
                event,
                allow_any,
            })
        }
        fn finish(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::UdxEdxfDiscountGroupElementType, Error> {
            let state = replace(
                &mut *self.state__,
                UdxEdxfDiscountGroupElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::UdxEdxfDiscountGroupElementType {
                content: helper.finish_vec(1usize, Some(2usize), self.content)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfDiscountGroupElementTypeContentDeserializer {
        state__: Box<UdxEdxfDiscountGroupElementTypeContentDeserializerState>,
    }
    #[derive(Debug)]
    pub enum UdxEdxfDiscountGroupElementTypeContentDeserializerState {
        Init__,
        UdxEdxfDiscountGroupManufacturer(
            Option<String>,
            Option<<String as WithDeserializer>::Deserializer>,
            Option<<String as WithDeserializer>::Deserializer>,
        ),
        UdxEdxfDiscountGroupSupplier(
            Option<String>,
            Option<<String as WithDeserializer>::Deserializer>,
            Option<<String as WithDeserializer>::Deserializer>,
        ),
        Done__(super::UdxEdxfDiscountGroupElementTypeContent),
        Unknown__,
    }
    impl UdxEdxfDiscountGroupElementTypeContentDeserializer {
        fn find_suitable<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            if let Event::Start(x) | Event::Empty(x) = &event {
                if matches!(
                    helper.resolve_local_name(x.name(), &super::NS_UNNAMED_5),
                    Some(b"UDX.EDXF.DISCOUNT_GROUP_MANUFACTURER")
                ) {
                    let output = <String as WithDeserializer>::init(helper, event)?;
                    return self.handle_udx_edxf_discount_group_manufacturer(
                        helper,
                        Default::default(),
                        None,
                        output,
                    );
                }
                if matches!(
                    helper.resolve_local_name(x.name(), &super::NS_UNNAMED_5),
                    Some(b"UDX.EDXF.DISCOUNT_GROUP_SUPPLIER")
                ) {
                    let output = <String as WithDeserializer>::init(helper, event)?;
                    return self.handle_udx_edxf_discount_group_supplier(
                        helper,
                        Default::default(),
                        None,
                        output,
                    );
                }
            }
            *self.state__ = UdxEdxfDiscountGroupElementTypeContentDeserializerState::Init__;
            Ok(ElementHandlerOutput::return_to_parent(event, false))
        }
        fn finish_state(
            helper: &mut DeserializeHelper,
            state: UdxEdxfDiscountGroupElementTypeContentDeserializerState,
        ) -> Result<super::UdxEdxfDiscountGroupElementTypeContent, Error> {
            use UdxEdxfDiscountGroupElementTypeContentDeserializerState as S;
            match state {
                S::Init__ => Err(ErrorKind::MissingContent.into()),
                S::UdxEdxfDiscountGroupManufacturer(mut values, None, deserializer) => {
                    if let Some(deserializer) = deserializer {
                        let value = deserializer.finish(helper)?;
                        Self::store_udx_edxf_discount_group_manufacturer(&mut values, value)?;
                    }
                    Ok (super :: UdxEdxfDiscountGroupElementTypeContent :: UdxEdxfDiscountGroupManufacturer (helper . finish_element ("UDX.EDXF.DISCOUNT_GROUP_MANUFACTURER" , values) ?))
                }
                S::UdxEdxfDiscountGroupSupplier(mut values, None, deserializer) => {
                    if let Some(deserializer) = deserializer {
                        let value = deserializer.finish(helper)?;
                        Self::store_udx_edxf_discount_group_supplier(&mut values, value)?;
                    }
                    Ok(
                        super::UdxEdxfDiscountGroupElementTypeContent::UdxEdxfDiscountGroupSupplier(
                            helper.finish_element("UDX.EDXF.DISCOUNT_GROUP_SUPPLIER", values)?,
                        ),
                    )
                }
                S::Done__(data) => Ok(data),
                _ => unreachable!(),
            }
        }
        fn store_udx_edxf_discount_group_manufacturer(
            values: &mut Option<String>,
            value: String,
        ) -> Result<(), Error> {
            if values.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.DISCOUNT_GROUP_MANUFACTURER",
                )))?;
            }
            *values = Some(value);
            Ok(())
        }
        fn store_udx_edxf_discount_group_supplier(
            values: &mut Option<String>,
            value: String,
        ) -> Result<(), Error> {
            if values.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.DISCOUNT_GROUP_SUPPLIER",
                )))?;
            }
            *values = Some(value);
            Ok(())
        }
        fn handle_udx_edxf_discount_group_manufacturer<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            mut values: Option<String>,
            fallback: Option<<String as WithDeserializer>::Deserializer>,
            output: DeserializerOutput<'de, String>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfDiscountGroupElementTypeContentDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
            }
            if let Some(deserializer) = fallback {
                let data = deserializer.finish(helper)?;
                Self::store_udx_edxf_discount_group_manufacturer(&mut values, data)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    Self::store_udx_edxf_discount_group_manufacturer(&mut values, data)?;
                    let data = Self::finish_state(
                        helper,
                        S::UdxEdxfDiscountGroupManufacturer(values, None, None),
                    )?;
                    *self.state__ = S::Done__(data);
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ =
                        S::UdxEdxfDiscountGroupManufacturer(values, None, Some(deserializer));
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_discount_group_supplier<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            mut values: Option<String>,
            fallback: Option<<String as WithDeserializer>::Deserializer>,
            output: DeserializerOutput<'de, String>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfDiscountGroupElementTypeContentDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
            }
            if let Some(deserializer) = fallback {
                let data = deserializer.finish(helper)?;
                Self::store_udx_edxf_discount_group_supplier(&mut values, data)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    Self::store_udx_edxf_discount_group_supplier(&mut values, data)?;
                    let data = Self::finish_state(
                        helper,
                        S::UdxEdxfDiscountGroupSupplier(values, None, None),
                    )?;
                    *self.state__ = S::Done__(data);
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ =
                        S::UdxEdxfDiscountGroupSupplier(values, None, Some(deserializer));
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::UdxEdxfDiscountGroupElementTypeContent>
        for UdxEdxfDiscountGroupElementTypeContentDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfDiscountGroupElementTypeContent> {
            let deserializer = Self {
                state__: Box::new(UdxEdxfDiscountGroupElementTypeContentDeserializerState::Init__),
            };
            let mut output = deserializer.next(helper, event)?;
            output.artifact = match output.artifact {
                DeserializerArtifact::Deserializer(x)
                    if matches!(
                        &*x.state__,
                        UdxEdxfDiscountGroupElementTypeContentDeserializerState::Init__
                    ) =>
                {
                    DeserializerArtifact::None
                }
                artifact => artifact,
            };
            Ok(output)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfDiscountGroupElementTypeContent> {
            use UdxEdxfDiscountGroupElementTypeContentDeserializerState as S;
            let mut event = event;
            let (event, allow_any) = loop {
                let state = replace(&mut *self.state__, S::Unknown__);
                event = match (state, event) {
                    (S::Unknown__, _) => unreachable!(),
                    (
                        S::UdxEdxfDiscountGroupManufacturer(values, fallback, Some(deserializer)),
                        event,
                    ) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_discount_group_manufacturer(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfDiscountGroupSupplier(values, fallback, Some(deserializer)),
                        event,
                    ) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_discount_group_supplier(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (state, event @ Event::End(_)) => {
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(Self::finish_state(
                                helper, state,
                            )?),
                            event: DeserializerEvent::Continue(event),
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => match self.find_suitable(helper, event)? {
                        ElementHandlerOutput::Break { event, allow_any } => {
                            break (event, allow_any)
                        }
                        ElementHandlerOutput::Continue { event, .. } => event,
                    },
                    (
                        S::UdxEdxfDiscountGroupManufacturer(values, fallback, None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.DISCOUNT_GROUP_MANUFACTURER",
                            false,
                        )?;
                        match self.handle_udx_edxf_discount_group_manufacturer(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfDiscountGroupSupplier(values, fallback, None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.DISCOUNT_GROUP_SUPPLIER",
                            false,
                        )?;
                        match self.handle_udx_edxf_discount_group_supplier(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (state @ S::Done__(_), event) => {
                        *self.state__ = state;
                        break (DeserializerEvent::Continue(event), false);
                    }
                    (state, event) => {
                        *self.state__ = state;
                        break (DeserializerEvent::Continue(event), false);
                    }
                }
            };
            let artifact = if matches!(&*self.state__, S::Done__(_)) {
                DeserializerArtifact::Data(self.finish(helper)?)
            } else {
                DeserializerArtifact::Deserializer(self)
            };
            Ok(DeserializerOutput {
                artifact,
                event,
                allow_any,
            })
        }
        fn finish(
            self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::UdxEdxfDiscountGroupElementTypeContent, Error> {
            Self::finish_state(helper, *self.state__)
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfDeclarationElementTypeDeserializer {
        type_: String,
        date: Option<String>,
        content: Option<String>,
        state__: Box<UdxEdxfDeclarationElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum UdxEdxfDeclarationElementTypeDeserializerState {
        Init__,
        Content__(<String as WithDeserializer>::Deserializer),
        Unknown__,
    }
    impl UdxEdxfDeclarationElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut type_: Option<String> = None;
            let mut date: Option<String> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"type")
                ) {
                    helper.read_attrib(&mut type_, b"type", &attrib.value)?;
                } else if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"date")
                ) {
                    helper.read_attrib(&mut date, b"date", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok(Self {
                type_: type_.ok_or_else(|| ErrorKind::MissingAttribute("type".into()))?,
                date: date,
                content: None,
                state__: Box::new(UdxEdxfDeclarationElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: UdxEdxfDeclarationElementTypeDeserializerState,
        ) -> Result<(), Error> {
            if let UdxEdxfDeclarationElementTypeDeserializerState::Content__(deserializer) = state {
                self.store_content(deserializer.finish(helper)?)?;
            }
            Ok(())
        }
        fn store_content(&mut self, value: String) -> Result<(), Error> {
            if self.content.is_some() {
                Err(ErrorKind::DuplicateContent)?;
            }
            self.content = Some(value);
            Ok(())
        }
        fn handle_content<'de>(
            mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
        ) -> DeserializerResult<'de, super::UdxEdxfDeclarationElementType> {
            use UdxEdxfDeclarationElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            match artifact {
                DeserializerArtifact::None => Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event,
                    allow_any,
                }),
                DeserializerArtifact::Data(data) => {
                    self.store_content(data)?;
                    let data = self.finish(helper)?;
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(data),
                        event,
                        allow_any,
                    })
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::Content__(deserializer);
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event,
                        allow_any,
                    })
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::UdxEdxfDeclarationElementType>
        for UdxEdxfDeclarationElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfDeclarationElementType> {
            let (Event::Start(x) | Event::Empty(x)) = &event else {
                return Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event: DeserializerEvent::Break(event),
                    allow_any: false,
                });
            };
            Self::from_bytes_start(helper, x)?.next(helper, event)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfDeclarationElementType> {
            use UdxEdxfDeclarationElementTypeDeserializerState as S;
            match replace(&mut *self.state__, S::Unknown__) {
                S::Unknown__ => unreachable!(),
                S::Init__ => {
                    let output = ContentDeserializer::init(helper, event)?;
                    self.handle_content(helper, output)
                }
                S::Content__(deserializer) => {
                    let output = deserializer.next(helper, event)?;
                    self.handle_content(helper, output)
                }
            }
        }
        fn finish(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::UdxEdxfDeclarationElementType, Error> {
            let state = replace(
                &mut *self.state__,
                UdxEdxfDeclarationElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::UdxEdxfDeclarationElementType {
                type_: self.type_,
                date: self.date,
                content: helper.finish_content(self.content)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfAdditionalFactorsElementTypeDeserializer {
        udx_edxf_additional_price_factor: Option<f64>,
        udx_edxf_additional_factor_info: Option<super::DtMlstring>,
        state__: Box<UdxEdxfAdditionalFactorsElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum UdxEdxfAdditionalFactorsElementTypeDeserializerState {
        Init__,
        UdxEdxfAdditionalPriceFactor(Option<<f64 as WithDeserializer>::Deserializer>),
        UdxEdxfAdditionalFactorInfo(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl UdxEdxfAdditionalFactorsElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                udx_edxf_additional_price_factor: None,
                udx_edxf_additional_factor_info: None,
                state__: Box::new(UdxEdxfAdditionalFactorsElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: UdxEdxfAdditionalFactorsElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use UdxEdxfAdditionalFactorsElementTypeDeserializerState as S;
            match state {
                S::UdxEdxfAdditionalPriceFactor(Some(deserializer)) => {
                    self.store_udx_edxf_additional_price_factor(deserializer.finish(helper)?)?
                }
                S::UdxEdxfAdditionalFactorInfo(Some(deserializer)) => {
                    self.store_udx_edxf_additional_factor_info(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_udx_edxf_additional_price_factor(&mut self, value: f64) -> Result<(), Error> {
            if self.udx_edxf_additional_price_factor.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.ADDITIONAL_PRICE_FACTOR",
                )))?;
            }
            self.udx_edxf_additional_price_factor = Some(value);
            Ok(())
        }
        fn store_udx_edxf_additional_factor_info(
            &mut self,
            value: super::DtMlstring,
        ) -> Result<(), Error> {
            if self.udx_edxf_additional_factor_info.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.ADDITIONAL_FACTOR_INFO",
                )))?;
            }
            self.udx_edxf_additional_factor_info = Some(value);
            Ok(())
        }
        fn handle_udx_edxf_additional_price_factor<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f64>,
            fallback: &mut Option<UdxEdxfAdditionalFactorsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfAdditionalFactorsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::UdxEdxfAdditionalPriceFactor(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_additional_price_factor(data)?;
                    *self.state__ = S::UdxEdxfAdditionalFactorInfo(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfAdditionalPriceFactor(Some(deserializer)));
                    *self.state__ = S::UdxEdxfAdditionalFactorInfo(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_additional_factor_info<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<UdxEdxfAdditionalFactorsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfAdditionalFactorsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::UdxEdxfAdditionalFactorInfo(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_additional_factor_info(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfAdditionalFactorInfo(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::UdxEdxfAdditionalFactorsElementType>
        for UdxEdxfAdditionalFactorsElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfAdditionalFactorsElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfAdditionalFactorsElementType> {
            use UdxEdxfAdditionalFactorsElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::UdxEdxfAdditionalPriceFactor(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_additional_price_factor(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfAdditionalFactorInfo(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_additional_factor_info(
                            helper,
                            output,
                            &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::UdxEdxfAdditionalPriceFactor(None);
                        event
                    }
                    (
                        S::UdxEdxfAdditionalPriceFactor(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.ADDITIONAL_PRICE_FACTOR",
                            false,
                        )?;
                        match self.handle_udx_edxf_additional_price_factor(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UdxEdxfAdditionalFactorInfo(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.ADDITIONAL_FACTOR_INFO",
                            false,
                        )?;
                        match self.handle_udx_edxf_additional_factor_info(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::UdxEdxfAdditionalFactorsElementType, Error> {
            let state = replace(
                &mut *self.state__,
                UdxEdxfAdditionalFactorsElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::UdxEdxfAdditionalFactorsElementType {
                udx_edxf_additional_price_factor: helper.finish_element(
                    "UDX.EDXF.ADDITIONAL_PRICE_FACTOR",
                    self.udx_edxf_additional_price_factor,
                )?,
                udx_edxf_additional_factor_info: helper.finish_element(
                    "UDX.EDXF.ADDITIONAL_FACTOR_INFO",
                    self.udx_edxf_additional_factor_info,
                )?,
            })
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfCountryBranchNumbersElementTypeDeserializer {
        udx_edxf_country_branch_number:
            Vec<super::UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementType>,
        state__: Box<UdxEdxfCountryBranchNumbersElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum UdxEdxfCountryBranchNumbersElementTypeDeserializerState {
        Init__ , UdxEdxfCountryBranchNumber (Option << super :: UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
    impl UdxEdxfCountryBranchNumbersElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                udx_edxf_country_branch_number: Vec::new(),
                state__: Box::new(UdxEdxfCountryBranchNumbersElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: UdxEdxfCountryBranchNumbersElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use UdxEdxfCountryBranchNumbersElementTypeDeserializerState as S;
            match state {
                S::UdxEdxfCountryBranchNumber(Some(deserializer)) => {
                    self.store_udx_edxf_country_branch_number(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_udx_edxf_country_branch_number(
            &mut self,
            value: super::UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementType,
        ) -> Result<(), Error> {
            self.udx_edxf_country_branch_number.push(value);
            Ok(())
        }
        fn handle_udx_edxf_country_branch_number<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<
                'de,
                super::UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementType,
            >,
            fallback: &mut Option<UdxEdxfCountryBranchNumbersElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfCountryBranchNumbersElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.udx_edxf_country_branch_number.len() < 1usize {
                    fallback.get_or_insert(S::UdxEdxfCountryBranchNumber(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_country_branch_number(data)?;
                    *self.state__ = S::UdxEdxfCountryBranchNumber(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfCountryBranchNumber(Some(deserializer)));
                    *self.state__ = S::UdxEdxfCountryBranchNumber(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::UdxEdxfCountryBranchNumbersElementType>
        for UdxEdxfCountryBranchNumbersElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfCountryBranchNumbersElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfCountryBranchNumbersElementType> {
            use UdxEdxfCountryBranchNumbersElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::UdxEdxfCountryBranchNumber(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_country_branch_number(
                            helper,
                            output,
                            &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::UdxEdxfCountryBranchNumber(None);
                        event
                    }
                    (
                        S::UdxEdxfCountryBranchNumber(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.COUNTRY_BRANCH_NUMBER",
                            false,
                        )?;
                        match self.handle_udx_edxf_country_branch_number(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::UdxEdxfCountryBranchNumbersElementType, Error> {
            let state = replace(
                &mut *self.state__,
                UdxEdxfCountryBranchNumbersElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::UdxEdxfCountryBranchNumbersElementType {
                udx_edxf_country_branch_number: helper.finish_vec(
                    1usize,
                    None,
                    self.udx_edxf_country_branch_number,
                )?,
            })
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfCountryBranchSupplierIdsElementTypeDeserializer {
        udx_edxf_country_branch_supplier_id:
            Vec<super::UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementType>,
        state__: Box<UdxEdxfCountryBranchSupplierIdsElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum UdxEdxfCountryBranchSupplierIdsElementTypeDeserializerState {
        Init__ , UdxEdxfCountryBranchSupplierId (Option << super :: UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementType as WithDeserializer > :: Deserializer >) , Done__ , Unknown__ , }
    impl UdxEdxfCountryBranchSupplierIdsElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                udx_edxf_country_branch_supplier_id: Vec::new(),
                state__: Box::new(
                    UdxEdxfCountryBranchSupplierIdsElementTypeDeserializerState::Init__,
                ),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: UdxEdxfCountryBranchSupplierIdsElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use UdxEdxfCountryBranchSupplierIdsElementTypeDeserializerState as S;
            match state {
                S::UdxEdxfCountryBranchSupplierId(Some(deserializer)) => {
                    self.store_udx_edxf_country_branch_supplier_id(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_udx_edxf_country_branch_supplier_id(
            &mut self,
            value: super::UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementType,
        ) -> Result<(), Error> {
            self.udx_edxf_country_branch_supplier_id.push(value);
            Ok(())
        }
        fn handle_udx_edxf_country_branch_supplier_id<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<
                'de,
                super::UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementType,
            >,
            fallback: &mut Option<UdxEdxfCountryBranchSupplierIdsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfCountryBranchSupplierIdsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.udx_edxf_country_branch_supplier_id.len() < 1usize {
                    fallback.get_or_insert(S::UdxEdxfCountryBranchSupplierId(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_country_branch_supplier_id(data)?;
                    *self.state__ = S::UdxEdxfCountryBranchSupplierId(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfCountryBranchSupplierId(Some(deserializer)));
                    *self.state__ = S::UdxEdxfCountryBranchSupplierId(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::UdxEdxfCountryBranchSupplierIdsElementType>
        for UdxEdxfCountryBranchSupplierIdsElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfCountryBranchSupplierIdsElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfCountryBranchSupplierIdsElementType> {
            use UdxEdxfCountryBranchSupplierIdsElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::UdxEdxfCountryBranchSupplierId(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_country_branch_supplier_id(
                            helper,
                            output,
                            &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::UdxEdxfCountryBranchSupplierId(None);
                        event
                    }
                    (
                        S::UdxEdxfCountryBranchSupplierId(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.COUNTRY_BRANCH_SUPPLIER_ID",
                            false,
                        )?;
                        match self.handle_udx_edxf_country_branch_supplier_id(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::UdxEdxfCountryBranchSupplierIdsElementType, Error> {
            let state = replace(
                &mut *self.state__,
                UdxEdxfCountryBranchSupplierIdsElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::UdxEdxfCountryBranchSupplierIdsElementType {
                udx_edxf_country_branch_supplier_id: helper.finish_vec(
                    1usize,
                    None,
                    self.udx_edxf_country_branch_supplier_id,
                )?,
            })
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfPackingUnitsElementTypeDeserializer {
        udx_edxf_packing_unit: Vec<super::UdxEdxfPackingUnitElementType>,
        state__: Box<UdxEdxfPackingUnitsElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum UdxEdxfPackingUnitsElementTypeDeserializerState {
        Init__,
        UdxEdxfPackingUnit(
            Option<<super::UdxEdxfPackingUnitElementType as WithDeserializer>::Deserializer>,
        ),
        Done__,
        Unknown__,
    }
    impl UdxEdxfPackingUnitsElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                udx_edxf_packing_unit: Vec::new(),
                state__: Box::new(UdxEdxfPackingUnitsElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: UdxEdxfPackingUnitsElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use UdxEdxfPackingUnitsElementTypeDeserializerState as S;
            match state {
                S::UdxEdxfPackingUnit(Some(deserializer)) => {
                    self.store_udx_edxf_packing_unit(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_udx_edxf_packing_unit(
            &mut self,
            value: super::UdxEdxfPackingUnitElementType,
        ) -> Result<(), Error> {
            self.udx_edxf_packing_unit.push(value);
            Ok(())
        }
        fn handle_udx_edxf_packing_unit<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::UdxEdxfPackingUnitElementType>,
            fallback: &mut Option<UdxEdxfPackingUnitsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfPackingUnitsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.udx_edxf_packing_unit.len() < 1usize {
                    fallback.get_or_insert(S::UdxEdxfPackingUnit(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_packing_unit(data)?;
                    *self.state__ = S::UdxEdxfPackingUnit(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfPackingUnit(Some(deserializer)));
                    *self.state__ = S::UdxEdxfPackingUnit(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::UdxEdxfPackingUnitsElementType>
        for UdxEdxfPackingUnitsElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfPackingUnitsElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfPackingUnitsElementType> {
            use UdxEdxfPackingUnitsElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::UdxEdxfPackingUnit(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_packing_unit(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::UdxEdxfPackingUnit(None);
                        event
                    }
                    (S::UdxEdxfPackingUnit(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.PACKING_UNIT",
                            false,
                        )?;
                        match self.handle_udx_edxf_packing_unit(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::UdxEdxfPackingUnitsElementType, Error> {
            let state = replace(
                &mut *self.state__,
                UdxEdxfPackingUnitsElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::UdxEdxfPackingUnitsElementType {
                udx_edxf_packing_unit: helper.finish_vec(
                    1usize,
                    None,
                    self.udx_edxf_packing_unit,
                )?,
            })
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfProductLogisticDetailsElementTypeDeserializer {
        udx_edxf_netweight: Option<f64>,
        udx_edxf_region_of_origin: Option<String>,
        state__: Box<UdxEdxfProductLogisticDetailsElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum UdxEdxfProductLogisticDetailsElementTypeDeserializerState {
        Init__,
        UdxEdxfNetweight(Option<<f64 as WithDeserializer>::Deserializer>),
        UdxEdxfRegionOfOrigin(Option<<String as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl UdxEdxfProductLogisticDetailsElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                udx_edxf_netweight: None,
                udx_edxf_region_of_origin: None,
                state__: Box::new(
                    UdxEdxfProductLogisticDetailsElementTypeDeserializerState::Init__,
                ),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: UdxEdxfProductLogisticDetailsElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use UdxEdxfProductLogisticDetailsElementTypeDeserializerState as S;
            match state {
                S::UdxEdxfNetweight(Some(deserializer)) => {
                    self.store_udx_edxf_netweight(deserializer.finish(helper)?)?
                }
                S::UdxEdxfRegionOfOrigin(Some(deserializer)) => {
                    self.store_udx_edxf_region_of_origin(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_udx_edxf_netweight(&mut self, value: f64) -> Result<(), Error> {
            if self.udx_edxf_netweight.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.NETWEIGHT",
                )))?;
            }
            self.udx_edxf_netweight = Some(value);
            Ok(())
        }
        fn store_udx_edxf_region_of_origin(&mut self, value: String) -> Result<(), Error> {
            if self.udx_edxf_region_of_origin.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.REGION_OF_ORIGIN",
                )))?;
            }
            self.udx_edxf_region_of_origin = Some(value);
            Ok(())
        }
        fn handle_udx_edxf_netweight<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f64>,
            fallback: &mut Option<UdxEdxfProductLogisticDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfProductLogisticDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfRegionOfOrigin(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_netweight(data)?;
                    *self.state__ = S::UdxEdxfRegionOfOrigin(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfNetweight(Some(deserializer)));
                    *self.state__ = S::UdxEdxfRegionOfOrigin(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_region_of_origin<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<UdxEdxfProductLogisticDetailsElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfProductLogisticDetailsElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Done__;
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_region_of_origin(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfRegionOfOrigin(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::UdxEdxfProductLogisticDetailsElementType>
        for UdxEdxfProductLogisticDetailsElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfProductLogisticDetailsElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfProductLogisticDetailsElementType> {
            use UdxEdxfProductLogisticDetailsElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::UdxEdxfNetweight(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_netweight(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfRegionOfOrigin(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_region_of_origin(
                            helper,
                            output,
                            &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::UdxEdxfNetweight(None);
                        event
                    }
                    (S::UdxEdxfNetweight(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.NETWEIGHT",
                            false,
                        )?;
                        match self.handle_udx_edxf_netweight(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UdxEdxfRegionOfOrigin(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.REGION_OF_ORIGIN",
                            false,
                        )?;
                        match self.handle_udx_edxf_region_of_origin(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::UdxEdxfProductLogisticDetailsElementType, Error> {
            let state = replace(
                &mut *self.state__,
                UdxEdxfProductLogisticDetailsElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::UdxEdxfProductLogisticDetailsElementType {
                udx_edxf_netweight: self.udx_edxf_netweight,
                udx_edxf_region_of_origin: self.udx_edxf_region_of_origin,
            })
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfReachElementTypeDeserializer {
        udx_edxf_reach_listdate: Option<String>,
        udx_edxf_reach_info: Option<String>,
        state__: Box<UdxEdxfReachElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum UdxEdxfReachElementTypeDeserializerState {
        Init__,
        UdxEdxfReachListdate(Option<<String as WithDeserializer>::Deserializer>),
        UdxEdxfReachInfo(Option<<String as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl UdxEdxfReachElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                udx_edxf_reach_listdate: None,
                udx_edxf_reach_info: None,
                state__: Box::new(UdxEdxfReachElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: UdxEdxfReachElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use UdxEdxfReachElementTypeDeserializerState as S;
            match state {
                S::UdxEdxfReachListdate(Some(deserializer)) => {
                    self.store_udx_edxf_reach_listdate(deserializer.finish(helper)?)?
                }
                S::UdxEdxfReachInfo(Some(deserializer)) => {
                    self.store_udx_edxf_reach_info(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_udx_edxf_reach_listdate(&mut self, value: String) -> Result<(), Error> {
            if self.udx_edxf_reach_listdate.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.REACH.LISTDATE",
                )))?;
            }
            self.udx_edxf_reach_listdate = Some(value);
            Ok(())
        }
        fn store_udx_edxf_reach_info(&mut self, value: String) -> Result<(), Error> {
            if self.udx_edxf_reach_info.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.REACH.INFO",
                )))?;
            }
            self.udx_edxf_reach_info = Some(value);
            Ok(())
        }
        fn handle_udx_edxf_reach_listdate<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<UdxEdxfReachElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfReachElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfReachInfo(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_reach_listdate(data)?;
                    *self.state__ = S::UdxEdxfReachInfo(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfReachListdate(Some(deserializer)));
                    *self.state__ = S::UdxEdxfReachInfo(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_reach_info<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<UdxEdxfReachElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfReachElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::UdxEdxfReachInfo(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_reach_info(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfReachInfo(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::UdxEdxfReachElementType>
        for UdxEdxfReachElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfReachElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfReachElementType> {
            use UdxEdxfReachElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::UdxEdxfReachListdate(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_reach_listdate(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfReachInfo(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_reach_info(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::UdxEdxfReachListdate(None);
                        event
                    }
                    (
                        S::UdxEdxfReachListdate(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.REACH.LISTDATE",
                            false,
                        )?;
                        match self.handle_udx_edxf_reach_listdate(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfReachInfo(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.REACH.INFO",
                            false,
                        )?;
                        match self.handle_udx_edxf_reach_info(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::UdxEdxfReachElementType, Error> {
            let state = replace(
                &mut *self.state__,
                UdxEdxfReachElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::UdxEdxfReachElementType {
                udx_edxf_reach_listdate: self.udx_edxf_reach_listdate,
                udx_edxf_reach_info: helper
                    .finish_element("UDX.EDXF.REACH.INFO", self.udx_edxf_reach_info)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfSurchargeListElementTypeDeserializer {
        udx_edxf_surcharge: Vec<super::UdxEdxfSurchargeElementType>,
        state__: Box<UdxEdxfSurchargeListElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum UdxEdxfSurchargeListElementTypeDeserializerState {
        Init__,
        UdxEdxfSurcharge(
            Option<<super::UdxEdxfSurchargeElementType as WithDeserializer>::Deserializer>,
        ),
        Done__,
        Unknown__,
    }
    impl UdxEdxfSurchargeListElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                udx_edxf_surcharge: Vec::new(),
                state__: Box::new(UdxEdxfSurchargeListElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: UdxEdxfSurchargeListElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use UdxEdxfSurchargeListElementTypeDeserializerState as S;
            match state {
                S::UdxEdxfSurcharge(Some(deserializer)) => {
                    self.store_udx_edxf_surcharge(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_udx_edxf_surcharge(
            &mut self,
            value: super::UdxEdxfSurchargeElementType,
        ) -> Result<(), Error> {
            self.udx_edxf_surcharge.push(value);
            Ok(())
        }
        fn handle_udx_edxf_surcharge<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::UdxEdxfSurchargeElementType>,
            fallback: &mut Option<UdxEdxfSurchargeListElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfSurchargeListElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                }
                if let Some(fallback) = fallback.take() {
                    self.finish_state(helper, fallback)?;
                }
                if self.udx_edxf_surcharge.len() < 1usize {
                    fallback.get_or_insert(S::UdxEdxfSurcharge(None));
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                } else {
                    *self.state__ = S::Done__;
                    return Ok(ElementHandlerOutput::from_event(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_surcharge(data)?;
                    *self.state__ = S::UdxEdxfSurcharge(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfSurcharge(Some(deserializer)));
                    *self.state__ = S::UdxEdxfSurcharge(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::UdxEdxfSurchargeListElementType>
        for UdxEdxfSurchargeListElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfSurchargeListElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfSurchargeListElementType> {
            use UdxEdxfSurchargeListElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::UdxEdxfSurcharge(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_surcharge(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::UdxEdxfSurcharge(None);
                        event
                    }
                    (S::UdxEdxfSurcharge(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.SURCHARGE",
                            false,
                        )?;
                        match self.handle_udx_edxf_surcharge(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::UdxEdxfSurchargeListElementType, Error> {
            let state = replace(
                &mut *self.state__,
                UdxEdxfSurchargeListElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::UdxEdxfSurchargeListElementType {
                udx_edxf_surcharge: helper.finish_vec(1usize, None, self.udx_edxf_surcharge)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct CustomsTariffNumberElementTypeDeserializer {
        customs_number: Option<String>,
        state__: Box<CustomsTariffNumberElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum CustomsTariffNumberElementTypeDeserializerState {
        Init__,
        CustomsNumber(Option<<String as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl CustomsTariffNumberElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                customs_number: None,
                state__: Box::new(CustomsTariffNumberElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: CustomsTariffNumberElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use CustomsTariffNumberElementTypeDeserializerState as S;
            match state {
                S::CustomsNumber(Some(deserializer)) => {
                    self.store_customs_number(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_customs_number(&mut self, value: String) -> Result<(), Error> {
            if self.customs_number.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"CUSTOMS_NUMBER",
                )))?;
            }
            self.customs_number = Some(value);
            Ok(())
        }
        fn handle_customs_number<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<CustomsTariffNumberElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use CustomsTariffNumberElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::CustomsNumber(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_customs_number(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::CustomsNumber(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::CustomsTariffNumberElementType>
        for CustomsTariffNumberElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::CustomsTariffNumberElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::CustomsTariffNumberElementType> {
            use CustomsTariffNumberElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::CustomsNumber(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_customs_number(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::CustomsNumber(None);
                        event
                    }
                    (S::CustomsNumber(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"CUSTOMS_NUMBER",
                            false,
                        )?;
                        match self.handle_customs_number(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::CustomsTariffNumberElementType, Error> {
            let state = replace(
                &mut *self.state__,
                CustomsTariffNumberElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::CustomsTariffNumberElementType {
                customs_number: helper.finish_element("CUSTOMS_NUMBER", self.customs_number)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeDeserializer {
        type_: String,
        country: String,
        content: Option<f64>,
        state__:
            Box<UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeDeserializerState {
        Init__,
        Content__(<f64 as WithDeserializer>::Deserializer),
        Unknown__,
    }
    impl UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut type_: Option<String> = None;
            let mut country: Option<String> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"type")
                ) {
                    helper.read_attrib(&mut type_, b"type", &attrib.value)?;
                } else if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"country")
                ) {
                    helper.read_attrib(&mut country, b"country", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok (Self { type_ : type_ . ok_or_else (|| ErrorKind :: MissingAttribute ("type" . into ())) ? , country : country . ok_or_else (|| ErrorKind :: MissingAttribute ("country" . into ())) ? , content : None , state__ : Box :: new (UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeDeserializerState :: Init__) , })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state : UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeDeserializerState,
        ) -> Result<(), Error> {
            if let UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeDeserializerState :: Content__ (deserializer) = state { self . store_content (deserializer . finish (helper) ?) ? ; }
            Ok(())
        }
        fn store_content(&mut self, value: f64) -> Result<(), Error> {
            if self.content.is_some() {
                Err(ErrorKind::DuplicateContent)?;
            }
            self.content = Some(value);
            Ok(())
        }
        fn handle_content<'de>(
            mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f64>,
        ) -> DeserializerResult<
            'de,
            super::UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementType,
        > {
            use UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            match artifact {
                DeserializerArtifact::None => Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event,
                    allow_any,
                }),
                DeserializerArtifact::Data(data) => {
                    self.store_content(data)?;
                    let data = self.finish(helper)?;
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(data),
                        event,
                        allow_any,
                    })
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::Content__(deserializer);
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event,
                        allow_any,
                    })
                }
            }
        }
    }
    impl<'de>
        Deserializer<'de, super::UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementType>
        for UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<
            'de,
            super::UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementType,
        > {
            let (Event::Start(x) | Event::Empty(x)) = &event else {
                return Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event: DeserializerEvent::Break(event),
                    allow_any: false,
                });
            };
            Self::from_bytes_start(helper, x)?.next(helper, event)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<
            'de,
            super::UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementType,
        > {
            use UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeDeserializerState as S;
            match replace(&mut *self.state__, S::Unknown__) {
                S::Unknown__ => unreachable!(),
                S::Init__ => {
                    let output = ContentDeserializer::init(helper, event)?;
                    self.handle_content(helper, output)
                }
                S::Content__(deserializer) => {
                    let output = deserializer.next(helper, event)?;
                    self.handle_content(helper, output)
                }
            }
        }
        fn finish(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementType, Error>
        {
            let state = replace (& mut * self . state__ , UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeDeserializerState :: Unknown__) ;
            self.finish_state(helper, state)?;
            Ok(
                super::UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementType {
                    type_: self.type_,
                    country: self.country,
                    content: helper.finish_content(self.content)?,
                },
            )
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeDeserializer { type_ : String , country : String , content : Option < f64 > , state__ : Box < UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeDeserializerState > , }
    #[derive(Debug)]
    enum UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeDeserializerState {
        Init__,
        Content__(<f64 as WithDeserializer>::Deserializer),
        Unknown__,
    }
    impl UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            let mut type_: Option<String> = None;
            let mut country: Option<String> = None;
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"type")
                ) {
                    helper.read_attrib(&mut type_, b"type", &attrib.value)?;
                } else if matches!(
                    helper.resolve_local_name(attrib.key, &super::NS_UNNAMED_5),
                    Some(b"country")
                ) {
                    helper.read_attrib(&mut country, b"country", &attrib.value)?;
                } else {
                    helper.raise_unexpected_attrib_checked(&attrib)?;
                }
            }
            Ok (Self { type_ : type_ . ok_or_else (|| ErrorKind :: MissingAttribute ("type" . into ())) ? , country : country . ok_or_else (|| ErrorKind :: MissingAttribute ("country" . into ())) ? , content : None , state__ : Box :: new (UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeDeserializerState :: Init__) , })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state : UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeDeserializerState,
        ) -> Result<(), Error> {
            if let UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeDeserializerState :: Content__ (deserializer) = state { self . store_content (deserializer . finish (helper) ?) ? ; }
            Ok(())
        }
        fn store_content(&mut self, value: f64) -> Result<(), Error> {
            if self.content.is_some() {
                Err(ErrorKind::DuplicateContent)?;
            }
            self.content = Some(value);
            Ok(())
        }
        fn handle_content<'de>(
            mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f64>,
        ) -> DeserializerResult<
            'de,
            super::UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementType,
        > {
            use UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            match artifact {
                DeserializerArtifact::None => Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event,
                    allow_any,
                }),
                DeserializerArtifact::Data(data) => {
                    self.store_content(data)?;
                    let data = self.finish(helper)?;
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Data(data),
                        event,
                        allow_any,
                    })
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::Content__(deserializer);
                    Ok(DeserializerOutput {
                        artifact: DeserializerArtifact::Deserializer(self),
                        event,
                        allow_any,
                    })
                }
            }
        }
    }
    impl<'de>
        Deserializer<
            'de,
            super::UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementType,
        > for UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<
            'de,
            super::UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementType,
        > {
            let (Event::Start(x) | Event::Empty(x)) = &event else {
                return Ok(DeserializerOutput {
                    artifact: DeserializerArtifact::None,
                    event: DeserializerEvent::Break(event),
                    allow_any: false,
                });
            };
            Self::from_bytes_start(helper, x)?.next(helper, event)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<
            'de,
            super::UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementType,
        > {
            use UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeDeserializerState as S;
            match replace(&mut *self.state__, S::Unknown__) {
                S::Unknown__ => unreachable!(),
                S::Init__ => {
                    let output = ContentDeserializer::init(helper, event)?;
                    self.handle_content(helper, output)
                }
                S::Content__(deserializer) => {
                    let output = deserializer.next(helper, event)?;
                    self.handle_content(helper, output)
                }
            }
        }
        fn finish(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<
            super::UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementType,
            Error,
        > {
            let state = replace (& mut * self . state__ , UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeDeserializerState :: Unknown__) ;
            self.finish_state(helper, state)?;
            Ok(
                super::UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementType {
                    type_: self.type_,
                    country: self.country,
                    content: helper.finish_content(self.content)?,
                },
            )
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfPackingUnitElementTypeDeserializer {
        udx_edxf_quantity_min: Option<f32>,
        udx_edxf_quantity_max: Option<f32>,
        udx_edxf_packing_unit_code: Option<super::DtPunit>,
        udx_edxf_packing_unit_name: Vec<super::DtMlstring>,
        udx_edxf_package_break: Option<String>,
        udx_edxf_volume: Option<f64>,
        udx_edxf_weight: Option<f64>,
        udx_edxf_length: Option<f64>,
        udx_edxf_width: Option<f64>,
        udx_edxf_depth: Option<f64>,
        udx_edxf_diameter: Option<f64>,
        udx_edxf_gtin: Option<String>,
        udx_edxf_gs_1128: Option<String>,
        state__: Box<UdxEdxfPackingUnitElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum UdxEdxfPackingUnitElementTypeDeserializerState {
        Init__,
        UdxEdxfQuantityMin(Option<<f32 as WithDeserializer>::Deserializer>),
        UdxEdxfQuantityMax(Option<<f32 as WithDeserializer>::Deserializer>),
        UdxEdxfPackingUnitCode(Option<<super::DtPunit as WithDeserializer>::Deserializer>),
        UdxEdxfPackingUnitName(Option<<super::DtMlstring as WithDeserializer>::Deserializer>),
        UdxEdxfPackageBreak(Option<<String as WithDeserializer>::Deserializer>),
        UdxEdxfVolume(Option<<f64 as WithDeserializer>::Deserializer>),
        UdxEdxfWeight(Option<<f64 as WithDeserializer>::Deserializer>),
        UdxEdxfLength(Option<<f64 as WithDeserializer>::Deserializer>),
        UdxEdxfWidth(Option<<f64 as WithDeserializer>::Deserializer>),
        UdxEdxfDepth(Option<<f64 as WithDeserializer>::Deserializer>),
        UdxEdxfDiameter(Option<<f64 as WithDeserializer>::Deserializer>),
        UdxEdxfGtin(Option<<String as WithDeserializer>::Deserializer>),
        UdxEdxfGs1128(Option<<String as WithDeserializer>::Deserializer>),
        Done__,
        Unknown__,
    }
    impl UdxEdxfPackingUnitElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                udx_edxf_quantity_min: None,
                udx_edxf_quantity_max: None,
                udx_edxf_packing_unit_code: None,
                udx_edxf_packing_unit_name: Vec::new(),
                udx_edxf_package_break: None,
                udx_edxf_volume: None,
                udx_edxf_weight: None,
                udx_edxf_length: None,
                udx_edxf_width: None,
                udx_edxf_depth: None,
                udx_edxf_diameter: None,
                udx_edxf_gtin: None,
                udx_edxf_gs_1128: None,
                state__: Box::new(UdxEdxfPackingUnitElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: UdxEdxfPackingUnitElementTypeDeserializerState,
        ) -> Result<(), Error> {
            use UdxEdxfPackingUnitElementTypeDeserializerState as S;
            match state {
                S::UdxEdxfQuantityMin(Some(deserializer)) => {
                    self.store_udx_edxf_quantity_min(deserializer.finish(helper)?)?
                }
                S::UdxEdxfQuantityMax(Some(deserializer)) => {
                    self.store_udx_edxf_quantity_max(deserializer.finish(helper)?)?
                }
                S::UdxEdxfPackingUnitCode(Some(deserializer)) => {
                    self.store_udx_edxf_packing_unit_code(deserializer.finish(helper)?)?
                }
                S::UdxEdxfPackingUnitName(Some(deserializer)) => {
                    self.store_udx_edxf_packing_unit_name(deserializer.finish(helper)?)?
                }
                S::UdxEdxfPackageBreak(Some(deserializer)) => {
                    self.store_udx_edxf_package_break(deserializer.finish(helper)?)?
                }
                S::UdxEdxfVolume(Some(deserializer)) => {
                    self.store_udx_edxf_volume(deserializer.finish(helper)?)?
                }
                S::UdxEdxfWeight(Some(deserializer)) => {
                    self.store_udx_edxf_weight(deserializer.finish(helper)?)?
                }
                S::UdxEdxfLength(Some(deserializer)) => {
                    self.store_udx_edxf_length(deserializer.finish(helper)?)?
                }
                S::UdxEdxfWidth(Some(deserializer)) => {
                    self.store_udx_edxf_width(deserializer.finish(helper)?)?
                }
                S::UdxEdxfDepth(Some(deserializer)) => {
                    self.store_udx_edxf_depth(deserializer.finish(helper)?)?
                }
                S::UdxEdxfDiameter(Some(deserializer)) => {
                    self.store_udx_edxf_diameter(deserializer.finish(helper)?)?
                }
                S::UdxEdxfGtin(Some(deserializer)) => {
                    self.store_udx_edxf_gtin(deserializer.finish(helper)?)?
                }
                S::UdxEdxfGs1128(Some(deserializer)) => {
                    self.store_udx_edxf_gs_1128(deserializer.finish(helper)?)?
                }
                _ => (),
            }
            Ok(())
        }
        fn store_udx_edxf_quantity_min(&mut self, value: f32) -> Result<(), Error> {
            if self.udx_edxf_quantity_min.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.QUANTITY_MIN",
                )))?;
            }
            self.udx_edxf_quantity_min = Some(value);
            Ok(())
        }
        fn store_udx_edxf_quantity_max(&mut self, value: f32) -> Result<(), Error> {
            if self.udx_edxf_quantity_max.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.QUANTITY_MAX",
                )))?;
            }
            self.udx_edxf_quantity_max = Some(value);
            Ok(())
        }
        fn store_udx_edxf_packing_unit_code(&mut self, value: super::DtPunit) -> Result<(), Error> {
            if self.udx_edxf_packing_unit_code.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.PACKING_UNIT_CODE",
                )))?;
            }
            self.udx_edxf_packing_unit_code = Some(value);
            Ok(())
        }
        fn store_udx_edxf_packing_unit_name(
            &mut self,
            value: super::DtMlstring,
        ) -> Result<(), Error> {
            self.udx_edxf_packing_unit_name.push(value);
            Ok(())
        }
        fn store_udx_edxf_package_break(&mut self, value: String) -> Result<(), Error> {
            if self.udx_edxf_package_break.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.PACKAGE_BREAK",
                )))?;
            }
            self.udx_edxf_package_break = Some(value);
            Ok(())
        }
        fn store_udx_edxf_volume(&mut self, value: f64) -> Result<(), Error> {
            if self.udx_edxf_volume.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.VOLUME",
                )))?;
            }
            self.udx_edxf_volume = Some(value);
            Ok(())
        }
        fn store_udx_edxf_weight(&mut self, value: f64) -> Result<(), Error> {
            if self.udx_edxf_weight.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.WEIGHT",
                )))?;
            }
            self.udx_edxf_weight = Some(value);
            Ok(())
        }
        fn store_udx_edxf_length(&mut self, value: f64) -> Result<(), Error> {
            if self.udx_edxf_length.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.LENGTH",
                )))?;
            }
            self.udx_edxf_length = Some(value);
            Ok(())
        }
        fn store_udx_edxf_width(&mut self, value: f64) -> Result<(), Error> {
            if self.udx_edxf_width.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.WIDTH",
                )))?;
            }
            self.udx_edxf_width = Some(value);
            Ok(())
        }
        fn store_udx_edxf_depth(&mut self, value: f64) -> Result<(), Error> {
            if self.udx_edxf_depth.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.DEPTH",
                )))?;
            }
            self.udx_edxf_depth = Some(value);
            Ok(())
        }
        fn store_udx_edxf_diameter(&mut self, value: f64) -> Result<(), Error> {
            if self.udx_edxf_diameter.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.DIAMETER",
                )))?;
            }
            self.udx_edxf_diameter = Some(value);
            Ok(())
        }
        fn store_udx_edxf_gtin(&mut self, value: String) -> Result<(), Error> {
            if self.udx_edxf_gtin.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.GTIN",
                )))?;
            }
            self.udx_edxf_gtin = Some(value);
            Ok(())
        }
        fn store_udx_edxf_gs_1128(&mut self, value: String) -> Result<(), Error> {
            if self.udx_edxf_gs_1128.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.GS1_128",
                )))?;
            }
            self.udx_edxf_gs_1128 = Some(value);
            Ok(())
        }
        fn handle_udx_edxf_quantity_min<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f32>,
            fallback: &mut Option<UdxEdxfPackingUnitElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfPackingUnitElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::UdxEdxfQuantityMin(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_quantity_min(data)?;
                    *self.state__ = S::UdxEdxfQuantityMax(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfQuantityMin(Some(deserializer)));
                    *self.state__ = S::UdxEdxfQuantityMax(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_quantity_max<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f32>,
            fallback: &mut Option<UdxEdxfPackingUnitElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfPackingUnitElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfPackingUnitCode(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_quantity_max(data)?;
                    *self.state__ = S::UdxEdxfPackingUnitCode(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfQuantityMax(Some(deserializer)));
                    *self.state__ = S::UdxEdxfPackingUnitCode(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_packing_unit_code<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtPunit>,
            fallback: &mut Option<UdxEdxfPackingUnitElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfPackingUnitElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                fallback.get_or_insert(S::UdxEdxfPackingUnitCode(None));
                if matches!(&fallback, Some(S::Init__)) {
                    return Ok(ElementHandlerOutput::break_(event, allow_any));
                } else {
                    return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
                }
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_packing_unit_code(data)?;
                    *self.state__ = S::UdxEdxfPackingUnitName(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfPackingUnitCode(Some(deserializer)));
                    *self.state__ = S::UdxEdxfPackingUnitName(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_packing_unit_name<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::DtMlstring>,
            fallback: &mut Option<UdxEdxfPackingUnitElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfPackingUnitElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfPackageBreak(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_packing_unit_name(data)?;
                    *self.state__ = S::UdxEdxfPackingUnitName(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfPackingUnitName(Some(deserializer)));
                    *self.state__ = S::UdxEdxfPackingUnitName(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_package_break<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<UdxEdxfPackingUnitElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfPackingUnitElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfVolume(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_package_break(data)?;
                    *self.state__ = S::UdxEdxfVolume(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfPackageBreak(Some(deserializer)));
                    *self.state__ = S::UdxEdxfVolume(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_volume<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f64>,
            fallback: &mut Option<UdxEdxfPackingUnitElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfPackingUnitElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfWeight(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_volume(data)?;
                    *self.state__ = S::UdxEdxfWeight(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfVolume(Some(deserializer)));
                    *self.state__ = S::UdxEdxfWeight(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_weight<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f64>,
            fallback: &mut Option<UdxEdxfPackingUnitElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfPackingUnitElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfLength(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_weight(data)?;
                    *self.state__ = S::UdxEdxfLength(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfWeight(Some(deserializer)));
                    *self.state__ = S::UdxEdxfLength(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_length<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f64>,
            fallback: &mut Option<UdxEdxfPackingUnitElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfPackingUnitElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfWidth(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_length(data)?;
                    *self.state__ = S::UdxEdxfWidth(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfLength(Some(deserializer)));
                    *self.state__ = S::UdxEdxfWidth(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_width<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f64>,
            fallback: &mut Option<UdxEdxfPackingUnitElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfPackingUnitElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfDepth(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_width(data)?;
                    *self.state__ = S::UdxEdxfDepth(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfWidth(Some(deserializer)));
                    *self.state__ = S::UdxEdxfDepth(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_depth<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f64>,
            fallback: &mut Option<UdxEdxfPackingUnitElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfPackingUnitElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfDiameter(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_depth(data)?;
                    *self.state__ = S::UdxEdxfDiameter(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfDepth(Some(deserializer)));
                    *self.state__ = S::UdxEdxfDiameter(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_diameter<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, f64>,
            fallback: &mut Option<UdxEdxfPackingUnitElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfPackingUnitElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfGtin(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_diameter(data)?;
                    *self.state__ = S::UdxEdxfGtin(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfDiameter(Some(deserializer)));
                    *self.state__ = S::UdxEdxfGtin(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_gtin<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<UdxEdxfPackingUnitElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfPackingUnitElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::UdxEdxfGs1128(None);
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_gtin(data)?;
                    *self.state__ = S::UdxEdxfGs1128(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfGtin(Some(deserializer)));
                    *self.state__ = S::UdxEdxfGs1128(None);
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_gs_1128<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, String>,
            fallback: &mut Option<UdxEdxfPackingUnitElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfPackingUnitElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = S::Done__;
                return Ok(ElementHandlerOutput::from_event(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_udx_edxf_gs_1128(data)?;
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    fallback.get_or_insert(S::UdxEdxfGs1128(Some(deserializer)));
                    *self.state__ = S::Done__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::UdxEdxfPackingUnitElementType>
        for UdxEdxfPackingUnitElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfPackingUnitElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfPackingUnitElementType> {
            use UdxEdxfPackingUnitElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::UdxEdxfQuantityMin(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_quantity_min(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfQuantityMax(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_quantity_max(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfPackingUnitCode(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_packing_unit_code(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfPackingUnitName(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_packing_unit_name(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfPackageBreak(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_package_break(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfVolume(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_volume(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfWeight(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_weight(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfLength(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_length(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfWidth(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_width(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfDepth(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_depth(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfDiameter(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_diameter(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfGtin(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_gtin(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfGs1128(Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_gs_1128(helper, output, &mut 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(helper, fallback)?;
                        }
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(self.finish(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => {
                        fallback.get_or_insert(S::Init__);
                        *self.state__ = S::UdxEdxfQuantityMin(None);
                        event
                    }
                    (S::UdxEdxfQuantityMin(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.QUANTITY_MIN",
                            false,
                        )?;
                        match self.handle_udx_edxf_quantity_min(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfQuantityMax(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.QUANTITY_MAX",
                            false,
                        )?;
                        match self.handle_udx_edxf_quantity_max(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UdxEdxfPackingUnitCode(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.PACKING_UNIT_CODE",
                            false,
                        )?;
                        match self.handle_udx_edxf_packing_unit_code(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (
                        S::UdxEdxfPackingUnitName(None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.PACKING_UNIT_NAME",
                            false,
                        )?;
                        match self.handle_udx_edxf_packing_unit_name(
                            helper,
                            output,
                            &mut fallback,
                        )? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfPackageBreak(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.PACKAGE_BREAK",
                            false,
                        )?;
                        match self.handle_udx_edxf_package_break(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfVolume(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.VOLUME",
                            false,
                        )?;
                        match self.handle_udx_edxf_volume(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfWeight(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.WEIGHT",
                            false,
                        )?;
                        match self.handle_udx_edxf_weight(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfLength(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.LENGTH",
                            false,
                        )?;
                        match self.handle_udx_edxf_length(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfWidth(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.WIDTH",
                            false,
                        )?;
                        match self.handle_udx_edxf_width(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfDepth(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.DEPTH",
                            false,
                        )?;
                        match self.handle_udx_edxf_depth(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfDiameter(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.DIAMETER",
                            false,
                        )?;
                        match self.handle_udx_edxf_diameter(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfGtin(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.GTIN",
                            false,
                        )?;
                        match self.handle_udx_edxf_gtin(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Continue { event, allow_any } => {
                                allow_any_element = allow_any_element || allow_any;
                                event
                            }
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                        }
                    }
                    (S::UdxEdxfGs1128(None), event @ (Event::Start(_) | Event::Empty(_))) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.GS1_128",
                            false,
                        )?;
                        match self.handle_udx_edxf_gs_1128(helper, output, &mut fallback)? {
                            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) => {
                        *self.state__ = S::Done__;
                        break (DeserializerEvent::Continue(event), allow_any_element);
                    }
                    (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(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::UdxEdxfPackingUnitElementType, Error> {
            let state = replace(
                &mut *self.state__,
                UdxEdxfPackingUnitElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::UdxEdxfPackingUnitElementType {
                udx_edxf_quantity_min: helper
                    .finish_element("UDX.EDXF.QUANTITY_MIN", self.udx_edxf_quantity_min)?,
                udx_edxf_quantity_max: self.udx_edxf_quantity_max,
                udx_edxf_packing_unit_code: helper.finish_element(
                    "UDX.EDXF.PACKING_UNIT_CODE",
                    self.udx_edxf_packing_unit_code,
                )?,
                udx_edxf_packing_unit_name: self.udx_edxf_packing_unit_name,
                udx_edxf_package_break: self.udx_edxf_package_break,
                udx_edxf_volume: self.udx_edxf_volume,
                udx_edxf_weight: self.udx_edxf_weight,
                udx_edxf_length: self.udx_edxf_length,
                udx_edxf_width: self.udx_edxf_width,
                udx_edxf_depth: self.udx_edxf_depth,
                udx_edxf_diameter: self.udx_edxf_diameter,
                udx_edxf_gtin: self.udx_edxf_gtin,
                udx_edxf_gs_1128: self.udx_edxf_gs_1128,
            })
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfSurchargeElementTypeDeserializer {
        content: Vec<super::UdxEdxfSurchargeElementTypeContent>,
        state__: Box<UdxEdxfSurchargeElementTypeDeserializerState>,
    }
    #[derive(Debug)]
    enum UdxEdxfSurchargeElementTypeDeserializerState {
        Init__,
        Next__,
        Content__(<super::UdxEdxfSurchargeElementTypeContent as WithDeserializer>::Deserializer),
        Unknown__,
    }
    impl UdxEdxfSurchargeElementTypeDeserializer {
        fn from_bytes_start(
            helper: &mut DeserializeHelper,
            bytes_start: &BytesStart<'_>,
        ) -> Result<Self, Error> {
            for attrib in helper.filter_xmlns_attributes(bytes_start) {
                let attrib = attrib?;
                helper.raise_unexpected_attrib_checked(&attrib)?;
            }
            Ok(Self {
                content: Vec::new(),
                state__: Box::new(UdxEdxfSurchargeElementTypeDeserializerState::Init__),
            })
        }
        fn finish_state(
            &mut self,
            helper: &mut DeserializeHelper,
            state: UdxEdxfSurchargeElementTypeDeserializerState,
        ) -> Result<(), Error> {
            if let UdxEdxfSurchargeElementTypeDeserializerState::Content__(deserializer) = state {
                self.store_content(deserializer.finish(helper)?)?;
            }
            Ok(())
        }
        fn store_content(
            &mut self,
            value: super::UdxEdxfSurchargeElementTypeContent,
        ) -> Result<(), Error> {
            self.content.push(value);
            Ok(())
        }
        fn handle_content<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            output: DeserializerOutput<'de, super::UdxEdxfSurchargeElementTypeContent>,
            fallback: &mut Option<UdxEdxfSurchargeElementTypeDeserializerState>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfSurchargeElementTypeDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                *self.state__ = fallback.take().unwrap_or(S::Next__);
                return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
            }
            if let Some(fallback) = fallback.take() {
                self.finish_state(helper, fallback)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    self.store_content(data)?;
                    *self.state__ = S::Next__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *fallback = Some(S::Content__(deserializer));
                    *self.state__ = S::Next__;
                    Ok(ElementHandlerOutput::from_event(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::UdxEdxfSurchargeElementType>
        for UdxEdxfSurchargeElementTypeDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfSurchargeElementType> {
            helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfSurchargeElementType> {
            use UdxEdxfSurchargeElementTypeDeserializerState 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::Unknown__, _) => unreachable!(),
                    (S::Content__(deserializer), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_content(helper, 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(helper)?),
                            event: DeserializerEvent::None,
                            allow_any: false,
                        });
                    }
                    (state @ (S::Init__ | S::Next__), event) => {
                        fallback.get_or_insert(state);
                        let output =
                            <super::UdxEdxfSurchargeElementTypeContent as WithDeserializer>::init(
                                helper, event,
                            )?;
                        match self.handle_content(helper, output, &mut fallback)? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                }
            };
            if let Some(fallback) = fallback {
                *self.state__ = fallback;
            }
            let artifact = DeserializerArtifact::Deserializer(self);
            Ok(DeserializerOutput {
                artifact,
                event,
                allow_any,
            })
        }
        fn finish(
            mut self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::UdxEdxfSurchargeElementType, Error> {
            let state = replace(
                &mut *self.state__,
                UdxEdxfSurchargeElementTypeDeserializerState::Unknown__,
            );
            self.finish_state(helper, state)?;
            Ok(super::UdxEdxfSurchargeElementType {
                content: helper.finish_vec(1usize, None, self.content)?,
            })
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfSurchargeElementTypeContentDeserializer {
        state__: Box<UdxEdxfSurchargeElementTypeContentDeserializerState>,
    }
    #[derive(Debug)]
    pub enum UdxEdxfSurchargeElementTypeContentDeserializerState {
        Init__,
        UdxEdxfSurchargeType(
            Option<String>,
            Option<<String as WithDeserializer>::Deserializer>,
            Option<<String as WithDeserializer>::Deserializer>,
        ),
        UdxEdxfSurchargeManner(
            Option<String>,
            Option<<String as WithDeserializer>::Deserializer>,
            Option<<String as WithDeserializer>::Deserializer>,
        ),
        UdxEdxfSurchargePercentage(
            Option<f64>,
            Option<<f64 as WithDeserializer>::Deserializer>,
            Option<<f64 as WithDeserializer>::Deserializer>,
        ),
        UdxEdxfSurchargePriceAmount(
            Option<f64>,
            Option<<f64 as WithDeserializer>::Deserializer>,
            Option<<f64 as WithDeserializer>::Deserializer>,
        ),
        UdxEdxfSurchargeCalculation(
            Option<f64>,
            Option<<f64 as WithDeserializer>::Deserializer>,
            Option<<f64 as WithDeserializer>::Deserializer>,
        ),
        UdxEdxfMaterialBasis(
            Option<f64>,
            Option<<f64 as WithDeserializer>::Deserializer>,
            Option<<f64 as WithDeserializer>::Deserializer>,
        ),
        UdxEdxfMaterialBasisWeight(
            Option<f64>,
            Option<<f64 as WithDeserializer>::Deserializer>,
            Option<<f64 as WithDeserializer>::Deserializer>,
        ),
        UdxEdxfMaterialBasisSurchargeThreshold(
            Option<f64>,
            Option<<f64 as WithDeserializer>::Deserializer>,
            Option<<f64 as WithDeserializer>::Deserializer>,
        ),
        UdxEdxfMaterialBasisSurchargeShutter(
            Option<i32>,
            Option<<i32 as WithDeserializer>::Deserializer>,
            Option<<i32 as WithDeserializer>::Deserializer>,
        ),
        UdxEdxfMaterialBasisSurchargeCredit(
            Option<i32>,
            Option<<i32 as WithDeserializer>::Deserializer>,
            Option<<i32 as WithDeserializer>::Deserializer>,
        ),
        UdxEdxfMaterialBasisSurchargeTable(
            Option<super::DtMlstring>,
            Option<<super::DtMlstring as WithDeserializer>::Deserializer>,
            Option<<super::DtMlstring as WithDeserializer>::Deserializer>,
        ),
        Done__(super::UdxEdxfSurchargeElementTypeContent),
        Unknown__,
    }
    impl UdxEdxfSurchargeElementTypeContentDeserializer {
        fn find_suitable<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            if let Event::Start(x) | Event::Empty(x) = &event {
                if matches!(
                    helper.resolve_local_name(x.name(), &super::NS_UNNAMED_5),
                    Some(b"UDX.EDXF.SURCHARGE_TYPE")
                ) {
                    let output = <String as WithDeserializer>::init(helper, event)?;
                    return self.handle_udx_edxf_surcharge_type(
                        helper,
                        Default::default(),
                        None,
                        output,
                    );
                }
                if matches!(
                    helper.resolve_local_name(x.name(), &super::NS_UNNAMED_5),
                    Some(b"UDX.EDXF.SURCHARGE_MANNER")
                ) {
                    let output = <String as WithDeserializer>::init(helper, event)?;
                    return self.handle_udx_edxf_surcharge_manner(
                        helper,
                        Default::default(),
                        None,
                        output,
                    );
                }
                if matches!(
                    helper.resolve_local_name(x.name(), &super::NS_UNNAMED_5),
                    Some(b"UDX.EDXF.SURCHARGE_PERCENTAGE")
                ) {
                    let output = <f64 as WithDeserializer>::init(helper, event)?;
                    return self.handle_udx_edxf_surcharge_percentage(
                        helper,
                        Default::default(),
                        None,
                        output,
                    );
                }
                if matches!(
                    helper.resolve_local_name(x.name(), &super::NS_UNNAMED_5),
                    Some(b"UDX.EDXF.SURCHARGE_PRICE_AMOUNT")
                ) {
                    let output = <f64 as WithDeserializer>::init(helper, event)?;
                    return self.handle_udx_edxf_surcharge_price_amount(
                        helper,
                        Default::default(),
                        None,
                        output,
                    );
                }
                if matches!(
                    helper.resolve_local_name(x.name(), &super::NS_UNNAMED_5),
                    Some(b"UDX.EDXF.SURCHARGE_CALCULATION")
                ) {
                    let output = <f64 as WithDeserializer>::init(helper, event)?;
                    return self.handle_udx_edxf_surcharge_calculation(
                        helper,
                        Default::default(),
                        None,
                        output,
                    );
                }
                if matches!(
                    helper.resolve_local_name(x.name(), &super::NS_UNNAMED_5),
                    Some(b"UDX.EDXF.MATERIAL_BASIS")
                ) {
                    let output = <f64 as WithDeserializer>::init(helper, event)?;
                    return self.handle_udx_edxf_material_basis(
                        helper,
                        Default::default(),
                        None,
                        output,
                    );
                }
                if matches!(
                    helper.resolve_local_name(x.name(), &super::NS_UNNAMED_5),
                    Some(b"UDX.EDXF.MATERIAL_BASIS_WEIGHT")
                ) {
                    let output = <f64 as WithDeserializer>::init(helper, event)?;
                    return self.handle_udx_edxf_material_basis_weight(
                        helper,
                        Default::default(),
                        None,
                        output,
                    );
                }
                if matches!(
                    helper.resolve_local_name(x.name(), &super::NS_UNNAMED_5),
                    Some(b"UDX.EDXF.MATERIAL_BASIS_SURCHARGE_THRESHOLD")
                ) {
                    let output = <f64 as WithDeserializer>::init(helper, event)?;
                    return self.handle_udx_edxf_material_basis_surcharge_threshold(
                        helper,
                        Default::default(),
                        None,
                        output,
                    );
                }
                if matches!(
                    helper.resolve_local_name(x.name(), &super::NS_UNNAMED_5),
                    Some(b"UDX.EDXF.MATERIAL_BASIS_SURCHARGE_SHUTTER")
                ) {
                    let output = <i32 as WithDeserializer>::init(helper, event)?;
                    return self.handle_udx_edxf_material_basis_surcharge_shutter(
                        helper,
                        Default::default(),
                        None,
                        output,
                    );
                }
                if matches!(
                    helper.resolve_local_name(x.name(), &super::NS_UNNAMED_5),
                    Some(b"UDX.EDXF.MATERIAL_BASIS_SURCHARGE_CREDIT")
                ) {
                    let output = <i32 as WithDeserializer>::init(helper, event)?;
                    return self.handle_udx_edxf_material_basis_surcharge_credit(
                        helper,
                        Default::default(),
                        None,
                        output,
                    );
                }
                if matches!(
                    helper.resolve_local_name(x.name(), &super::NS_UNNAMED_5),
                    Some(b"UDX.EDXF.MATERIAL_BASIS_SURCHARGE_TABLE")
                ) {
                    let output = <super::DtMlstring as WithDeserializer>::init(helper, event)?;
                    return self.handle_udx_edxf_material_basis_surcharge_table(
                        helper,
                        Default::default(),
                        None,
                        output,
                    );
                }
            }
            *self.state__ = UdxEdxfSurchargeElementTypeContentDeserializerState::Init__;
            Ok(ElementHandlerOutput::return_to_parent(event, false))
        }
        fn finish_state(
            helper: &mut DeserializeHelper,
            state: UdxEdxfSurchargeElementTypeContentDeserializerState,
        ) -> Result<super::UdxEdxfSurchargeElementTypeContent, Error> {
            use UdxEdxfSurchargeElementTypeContentDeserializerState as S;
            match state {
                S::Init__ => Err(ErrorKind::MissingContent.into()),
                S::UdxEdxfSurchargeType(mut values, None, deserializer) => {
                    if let Some(deserializer) = deserializer {
                        let value = deserializer.finish(helper)?;
                        Self::store_udx_edxf_surcharge_type(&mut values, value)?;
                    }
                    Ok(
                        super::UdxEdxfSurchargeElementTypeContent::UdxEdxfSurchargeType(
                            helper.finish_element("UDX.EDXF.SURCHARGE_TYPE", values)?,
                        ),
                    )
                }
                S::UdxEdxfSurchargeManner(mut values, None, deserializer) => {
                    if let Some(deserializer) = deserializer {
                        let value = deserializer.finish(helper)?;
                        Self::store_udx_edxf_surcharge_manner(&mut values, value)?;
                    }
                    Ok(
                        super::UdxEdxfSurchargeElementTypeContent::UdxEdxfSurchargeManner(
                            helper.finish_element("UDX.EDXF.SURCHARGE_MANNER", values)?,
                        ),
                    )
                }
                S::UdxEdxfSurchargePercentage(mut values, None, deserializer) => {
                    if let Some(deserializer) = deserializer {
                        let value = deserializer.finish(helper)?;
                        Self::store_udx_edxf_surcharge_percentage(&mut values, value)?;
                    }
                    Ok(
                        super::UdxEdxfSurchargeElementTypeContent::UdxEdxfSurchargePercentage(
                            helper.finish_element("UDX.EDXF.SURCHARGE_PERCENTAGE", values)?,
                        ),
                    )
                }
                S::UdxEdxfSurchargePriceAmount(mut values, None, deserializer) => {
                    if let Some(deserializer) = deserializer {
                        let value = deserializer.finish(helper)?;
                        Self::store_udx_edxf_surcharge_price_amount(&mut values, value)?;
                    }
                    Ok(
                        super::UdxEdxfSurchargeElementTypeContent::UdxEdxfSurchargePriceAmount(
                            helper.finish_element("UDX.EDXF.SURCHARGE_PRICE_AMOUNT", values)?,
                        ),
                    )
                }
                S::UdxEdxfSurchargeCalculation(mut values, None, deserializer) => {
                    if let Some(deserializer) = deserializer {
                        let value = deserializer.finish(helper)?;
                        Self::store_udx_edxf_surcharge_calculation(&mut values, value)?;
                    }
                    Ok(
                        super::UdxEdxfSurchargeElementTypeContent::UdxEdxfSurchargeCalculation(
                            helper.finish_element("UDX.EDXF.SURCHARGE_CALCULATION", values)?,
                        ),
                    )
                }
                S::UdxEdxfMaterialBasis(mut values, None, deserializer) => {
                    if let Some(deserializer) = deserializer {
                        let value = deserializer.finish(helper)?;
                        Self::store_udx_edxf_material_basis(&mut values, value)?;
                    }
                    Ok(
                        super::UdxEdxfSurchargeElementTypeContent::UdxEdxfMaterialBasis(
                            helper.finish_element("UDX.EDXF.MATERIAL_BASIS", values)?,
                        ),
                    )
                }
                S::UdxEdxfMaterialBasisWeight(mut values, None, deserializer) => {
                    if let Some(deserializer) = deserializer {
                        let value = deserializer.finish(helper)?;
                        Self::store_udx_edxf_material_basis_weight(&mut values, value)?;
                    }
                    Ok(
                        super::UdxEdxfSurchargeElementTypeContent::UdxEdxfMaterialBasisWeight(
                            helper.finish_element("UDX.EDXF.MATERIAL_BASIS_WEIGHT", values)?,
                        ),
                    )
                }
                S::UdxEdxfMaterialBasisSurchargeThreshold(mut values, None, deserializer) => {
                    if let Some(deserializer) = deserializer {
                        let value = deserializer.finish(helper)?;
                        Self::store_udx_edxf_material_basis_surcharge_threshold(
                            &mut values,
                            value,
                        )?;
                    }
                    Ok (super :: UdxEdxfSurchargeElementTypeContent :: UdxEdxfMaterialBasisSurchargeThreshold (helper . finish_element ("UDX.EDXF.MATERIAL_BASIS_SURCHARGE_THRESHOLD" , values) ?))
                }
                S::UdxEdxfMaterialBasisSurchargeShutter(mut values, None, deserializer) => {
                    if let Some(deserializer) = deserializer {
                        let value = deserializer.finish(helper)?;
                        Self::store_udx_edxf_material_basis_surcharge_shutter(&mut values, value)?;
                    }
                    Ok (super :: UdxEdxfSurchargeElementTypeContent :: UdxEdxfMaterialBasisSurchargeShutter (helper . finish_element ("UDX.EDXF.MATERIAL_BASIS_SURCHARGE_SHUTTER" , values) ?))
                }
                S::UdxEdxfMaterialBasisSurchargeCredit(mut values, None, deserializer) => {
                    if let Some(deserializer) = deserializer {
                        let value = deserializer.finish(helper)?;
                        Self::store_udx_edxf_material_basis_surcharge_credit(&mut values, value)?;
                    }
                    Ok (super :: UdxEdxfSurchargeElementTypeContent :: UdxEdxfMaterialBasisSurchargeCredit (helper . finish_element ("UDX.EDXF.MATERIAL_BASIS_SURCHARGE_CREDIT" , values) ?))
                }
                S::UdxEdxfMaterialBasisSurchargeTable(mut values, None, deserializer) => {
                    if let Some(deserializer) = deserializer {
                        let value = deserializer.finish(helper)?;
                        Self::store_udx_edxf_material_basis_surcharge_table(&mut values, value)?;
                    }
                    Ok (super :: UdxEdxfSurchargeElementTypeContent :: UdxEdxfMaterialBasisSurchargeTable (helper . finish_element ("UDX.EDXF.MATERIAL_BASIS_SURCHARGE_TABLE" , values) ?))
                }
                S::Done__(data) => Ok(data),
                _ => unreachable!(),
            }
        }
        fn store_udx_edxf_surcharge_type(
            values: &mut Option<String>,
            value: String,
        ) -> Result<(), Error> {
            if values.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.SURCHARGE_TYPE",
                )))?;
            }
            *values = Some(value);
            Ok(())
        }
        fn store_udx_edxf_surcharge_manner(
            values: &mut Option<String>,
            value: String,
        ) -> Result<(), Error> {
            if values.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.SURCHARGE_MANNER",
                )))?;
            }
            *values = Some(value);
            Ok(())
        }
        fn store_udx_edxf_surcharge_percentage(
            values: &mut Option<f64>,
            value: f64,
        ) -> Result<(), Error> {
            if values.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.SURCHARGE_PERCENTAGE",
                )))?;
            }
            *values = Some(value);
            Ok(())
        }
        fn store_udx_edxf_surcharge_price_amount(
            values: &mut Option<f64>,
            value: f64,
        ) -> Result<(), Error> {
            if values.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.SURCHARGE_PRICE_AMOUNT",
                )))?;
            }
            *values = Some(value);
            Ok(())
        }
        fn store_udx_edxf_surcharge_calculation(
            values: &mut Option<f64>,
            value: f64,
        ) -> Result<(), Error> {
            if values.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.SURCHARGE_CALCULATION",
                )))?;
            }
            *values = Some(value);
            Ok(())
        }
        fn store_udx_edxf_material_basis(
            values: &mut Option<f64>,
            value: f64,
        ) -> Result<(), Error> {
            if values.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.MATERIAL_BASIS",
                )))?;
            }
            *values = Some(value);
            Ok(())
        }
        fn store_udx_edxf_material_basis_weight(
            values: &mut Option<f64>,
            value: f64,
        ) -> Result<(), Error> {
            if values.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.MATERIAL_BASIS_WEIGHT",
                )))?;
            }
            *values = Some(value);
            Ok(())
        }
        fn store_udx_edxf_material_basis_surcharge_threshold(
            values: &mut Option<f64>,
            value: f64,
        ) -> Result<(), Error> {
            if values.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.MATERIAL_BASIS_SURCHARGE_THRESHOLD",
                )))?;
            }
            *values = Some(value);
            Ok(())
        }
        fn store_udx_edxf_material_basis_surcharge_shutter(
            values: &mut Option<i32>,
            value: i32,
        ) -> Result<(), Error> {
            if values.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.MATERIAL_BASIS_SURCHARGE_SHUTTER",
                )))?;
            }
            *values = Some(value);
            Ok(())
        }
        fn store_udx_edxf_material_basis_surcharge_credit(
            values: &mut Option<i32>,
            value: i32,
        ) -> Result<(), Error> {
            if values.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.MATERIAL_BASIS_SURCHARGE_CREDIT",
                )))?;
            }
            *values = Some(value);
            Ok(())
        }
        fn store_udx_edxf_material_basis_surcharge_table(
            values: &mut Option<super::DtMlstring>,
            value: super::DtMlstring,
        ) -> Result<(), Error> {
            if values.is_some() {
                Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
                    b"UDX.EDXF.MATERIAL_BASIS_SURCHARGE_TABLE",
                )))?;
            }
            *values = Some(value);
            Ok(())
        }
        fn handle_udx_edxf_surcharge_type<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            mut values: Option<String>,
            fallback: Option<<String as WithDeserializer>::Deserializer>,
            output: DeserializerOutput<'de, String>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfSurchargeElementTypeContentDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
            }
            if let Some(deserializer) = fallback {
                let data = deserializer.finish(helper)?;
                Self::store_udx_edxf_surcharge_type(&mut values, data)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    Self::store_udx_edxf_surcharge_type(&mut values, data)?;
                    let data =
                        Self::finish_state(helper, S::UdxEdxfSurchargeType(values, None, None))?;
                    *self.state__ = S::Done__(data);
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::UdxEdxfSurchargeType(values, None, Some(deserializer));
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_surcharge_manner<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            mut values: Option<String>,
            fallback: Option<<String as WithDeserializer>::Deserializer>,
            output: DeserializerOutput<'de, String>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfSurchargeElementTypeContentDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
            }
            if let Some(deserializer) = fallback {
                let data = deserializer.finish(helper)?;
                Self::store_udx_edxf_surcharge_manner(&mut values, data)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    Self::store_udx_edxf_surcharge_manner(&mut values, data)?;
                    let data =
                        Self::finish_state(helper, S::UdxEdxfSurchargeManner(values, None, None))?;
                    *self.state__ = S::Done__(data);
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::UdxEdxfSurchargeManner(values, None, Some(deserializer));
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_surcharge_percentage<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            mut values: Option<f64>,
            fallback: Option<<f64 as WithDeserializer>::Deserializer>,
            output: DeserializerOutput<'de, f64>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfSurchargeElementTypeContentDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
            }
            if let Some(deserializer) = fallback {
                let data = deserializer.finish(helper)?;
                Self::store_udx_edxf_surcharge_percentage(&mut values, data)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    Self::store_udx_edxf_surcharge_percentage(&mut values, data)?;
                    let data = Self::finish_state(
                        helper,
                        S::UdxEdxfSurchargePercentage(values, None, None),
                    )?;
                    *self.state__ = S::Done__(data);
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::UdxEdxfSurchargePercentage(values, None, Some(deserializer));
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_surcharge_price_amount<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            mut values: Option<f64>,
            fallback: Option<<f64 as WithDeserializer>::Deserializer>,
            output: DeserializerOutput<'de, f64>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfSurchargeElementTypeContentDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
            }
            if let Some(deserializer) = fallback {
                let data = deserializer.finish(helper)?;
                Self::store_udx_edxf_surcharge_price_amount(&mut values, data)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    Self::store_udx_edxf_surcharge_price_amount(&mut values, data)?;
                    let data = Self::finish_state(
                        helper,
                        S::UdxEdxfSurchargePriceAmount(values, None, None),
                    )?;
                    *self.state__ = S::Done__(data);
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ =
                        S::UdxEdxfSurchargePriceAmount(values, None, Some(deserializer));
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_surcharge_calculation<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            mut values: Option<f64>,
            fallback: Option<<f64 as WithDeserializer>::Deserializer>,
            output: DeserializerOutput<'de, f64>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfSurchargeElementTypeContentDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
            }
            if let Some(deserializer) = fallback {
                let data = deserializer.finish(helper)?;
                Self::store_udx_edxf_surcharge_calculation(&mut values, data)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    Self::store_udx_edxf_surcharge_calculation(&mut values, data)?;
                    let data = Self::finish_state(
                        helper,
                        S::UdxEdxfSurchargeCalculation(values, None, None),
                    )?;
                    *self.state__ = S::Done__(data);
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ =
                        S::UdxEdxfSurchargeCalculation(values, None, Some(deserializer));
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_material_basis<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            mut values: Option<f64>,
            fallback: Option<<f64 as WithDeserializer>::Deserializer>,
            output: DeserializerOutput<'de, f64>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfSurchargeElementTypeContentDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
            }
            if let Some(deserializer) = fallback {
                let data = deserializer.finish(helper)?;
                Self::store_udx_edxf_material_basis(&mut values, data)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    Self::store_udx_edxf_material_basis(&mut values, data)?;
                    let data =
                        Self::finish_state(helper, S::UdxEdxfMaterialBasis(values, None, None))?;
                    *self.state__ = S::Done__(data);
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::UdxEdxfMaterialBasis(values, None, Some(deserializer));
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_material_basis_weight<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            mut values: Option<f64>,
            fallback: Option<<f64 as WithDeserializer>::Deserializer>,
            output: DeserializerOutput<'de, f64>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfSurchargeElementTypeContentDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
            }
            if let Some(deserializer) = fallback {
                let data = deserializer.finish(helper)?;
                Self::store_udx_edxf_material_basis_weight(&mut values, data)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    Self::store_udx_edxf_material_basis_weight(&mut values, data)?;
                    let data = Self::finish_state(
                        helper,
                        S::UdxEdxfMaterialBasisWeight(values, None, None),
                    )?;
                    *self.state__ = S::Done__(data);
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ = S::UdxEdxfMaterialBasisWeight(values, None, Some(deserializer));
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_material_basis_surcharge_threshold<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            mut values: Option<f64>,
            fallback: Option<<f64 as WithDeserializer>::Deserializer>,
            output: DeserializerOutput<'de, f64>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfSurchargeElementTypeContentDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
            }
            if let Some(deserializer) = fallback {
                let data = deserializer.finish(helper)?;
                Self::store_udx_edxf_material_basis_surcharge_threshold(&mut values, data)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    Self::store_udx_edxf_material_basis_surcharge_threshold(&mut values, data)?;
                    let data = Self::finish_state(
                        helper,
                        S::UdxEdxfMaterialBasisSurchargeThreshold(values, None, None),
                    )?;
                    *self.state__ = S::Done__(data);
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ =
                        S::UdxEdxfMaterialBasisSurchargeThreshold(values, None, Some(deserializer));
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_material_basis_surcharge_shutter<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            mut values: Option<i32>,
            fallback: Option<<i32 as WithDeserializer>::Deserializer>,
            output: DeserializerOutput<'de, i32>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfSurchargeElementTypeContentDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
            }
            if let Some(deserializer) = fallback {
                let data = deserializer.finish(helper)?;
                Self::store_udx_edxf_material_basis_surcharge_shutter(&mut values, data)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    Self::store_udx_edxf_material_basis_surcharge_shutter(&mut values, data)?;
                    let data = Self::finish_state(
                        helper,
                        S::UdxEdxfMaterialBasisSurchargeShutter(values, None, None),
                    )?;
                    *self.state__ = S::Done__(data);
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ =
                        S::UdxEdxfMaterialBasisSurchargeShutter(values, None, Some(deserializer));
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_material_basis_surcharge_credit<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            mut values: Option<i32>,
            fallback: Option<<i32 as WithDeserializer>::Deserializer>,
            output: DeserializerOutput<'de, i32>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfSurchargeElementTypeContentDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
            }
            if let Some(deserializer) = fallback {
                let data = deserializer.finish(helper)?;
                Self::store_udx_edxf_material_basis_surcharge_credit(&mut values, data)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    Self::store_udx_edxf_material_basis_surcharge_credit(&mut values, data)?;
                    let data = Self::finish_state(
                        helper,
                        S::UdxEdxfMaterialBasisSurchargeCredit(values, None, None),
                    )?;
                    *self.state__ = S::Done__(data);
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ =
                        S::UdxEdxfMaterialBasisSurchargeCredit(values, None, Some(deserializer));
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
            }
        }
        fn handle_udx_edxf_material_basis_surcharge_table<'de>(
            &mut self,
            helper: &mut DeserializeHelper,
            mut values: Option<super::DtMlstring>,
            fallback: Option<<super::DtMlstring as WithDeserializer>::Deserializer>,
            output: DeserializerOutput<'de, super::DtMlstring>,
        ) -> Result<ElementHandlerOutput<'de>, Error> {
            use UdxEdxfSurchargeElementTypeContentDeserializerState as S;
            let DeserializerOutput {
                artifact,
                event,
                allow_any,
            } = output;
            if artifact.is_none() {
                return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
            }
            if let Some(deserializer) = fallback {
                let data = deserializer.finish(helper)?;
                Self::store_udx_edxf_material_basis_surcharge_table(&mut values, data)?;
            }
            match artifact {
                DeserializerArtifact::None => unreachable!(),
                DeserializerArtifact::Data(data) => {
                    Self::store_udx_edxf_material_basis_surcharge_table(&mut values, data)?;
                    let data = Self::finish_state(
                        helper,
                        S::UdxEdxfMaterialBasisSurchargeTable(values, None, None),
                    )?;
                    *self.state__ = S::Done__(data);
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
                DeserializerArtifact::Deserializer(deserializer) => {
                    *self.state__ =
                        S::UdxEdxfMaterialBasisSurchargeTable(values, None, Some(deserializer));
                    Ok(ElementHandlerOutput::break_(event, allow_any))
                }
            }
        }
    }
    impl<'de> Deserializer<'de, super::UdxEdxfSurchargeElementTypeContent>
        for UdxEdxfSurchargeElementTypeContentDeserializer
    {
        fn init(
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfSurchargeElementTypeContent> {
            let deserializer = Self {
                state__: Box::new(UdxEdxfSurchargeElementTypeContentDeserializerState::Init__),
            };
            let mut output = deserializer.next(helper, event)?;
            output.artifact = match output.artifact {
                DeserializerArtifact::Deserializer(x)
                    if matches!(
                        &*x.state__,
                        UdxEdxfSurchargeElementTypeContentDeserializerState::Init__
                    ) =>
                {
                    DeserializerArtifact::None
                }
                artifact => artifact,
            };
            Ok(output)
        }
        fn next(
            mut self,
            helper: &mut DeserializeHelper,
            event: Event<'de>,
        ) -> DeserializerResult<'de, super::UdxEdxfSurchargeElementTypeContent> {
            use UdxEdxfSurchargeElementTypeContentDeserializerState as S;
            let mut event = event;
            let (event, allow_any) = loop {
                let state = replace(&mut *self.state__, S::Unknown__);
                event = match (state, event) {
                    (S::Unknown__, _) => unreachable!(),
                    (S::UdxEdxfSurchargeType(values, fallback, Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self
                            .handle_udx_edxf_surcharge_type(helper, values, fallback, output)?
                        {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (S::UdxEdxfSurchargeManner(values, fallback, Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self
                            .handle_udx_edxf_surcharge_manner(helper, values, fallback, output)?
                        {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfSurchargePercentage(values, fallback, Some(deserializer)),
                        event,
                    ) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_surcharge_percentage(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfSurchargePriceAmount(values, fallback, Some(deserializer)),
                        event,
                    ) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_surcharge_price_amount(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfSurchargeCalculation(values, fallback, Some(deserializer)),
                        event,
                    ) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_surcharge_calculation(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (S::UdxEdxfMaterialBasis(values, fallback, Some(deserializer)), event) => {
                        let output = deserializer.next(helper, event)?;
                        match self
                            .handle_udx_edxf_material_basis(helper, values, fallback, output)?
                        {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfMaterialBasisWeight(values, fallback, Some(deserializer)),
                        event,
                    ) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_material_basis_weight(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfMaterialBasisSurchargeThreshold(
                            values,
                            fallback,
                            Some(deserializer),
                        ),
                        event,
                    ) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_material_basis_surcharge_threshold(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfMaterialBasisSurchargeShutter(
                            values,
                            fallback,
                            Some(deserializer),
                        ),
                        event,
                    ) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_material_basis_surcharge_shutter(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfMaterialBasisSurchargeCredit(
                            values,
                            fallback,
                            Some(deserializer),
                        ),
                        event,
                    ) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_material_basis_surcharge_credit(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfMaterialBasisSurchargeTable(values, fallback, Some(deserializer)),
                        event,
                    ) => {
                        let output = deserializer.next(helper, event)?;
                        match self.handle_udx_edxf_material_basis_surcharge_table(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (state, event @ Event::End(_)) => {
                        return Ok(DeserializerOutput {
                            artifact: DeserializerArtifact::Data(Self::finish_state(
                                helper, state,
                            )?),
                            event: DeserializerEvent::Continue(event),
                            allow_any: false,
                        });
                    }
                    (S::Init__, event) => match self.find_suitable(helper, event)? {
                        ElementHandlerOutput::Break { event, allow_any } => {
                            break (event, allow_any)
                        }
                        ElementHandlerOutput::Continue { event, .. } => event,
                    },
                    (
                        S::UdxEdxfSurchargeType(values, fallback, None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.SURCHARGE_TYPE",
                            false,
                        )?;
                        match self
                            .handle_udx_edxf_surcharge_type(helper, values, fallback, output)?
                        {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfSurchargeManner(values, fallback, None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.SURCHARGE_MANNER",
                            false,
                        )?;
                        match self
                            .handle_udx_edxf_surcharge_manner(helper, values, fallback, output)?
                        {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfSurchargePercentage(values, fallback, None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.SURCHARGE_PERCENTAGE",
                            false,
                        )?;
                        match self.handle_udx_edxf_surcharge_percentage(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfSurchargePriceAmount(values, fallback, None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.SURCHARGE_PRICE_AMOUNT",
                            false,
                        )?;
                        match self.handle_udx_edxf_surcharge_price_amount(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfSurchargeCalculation(values, fallback, None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.SURCHARGE_CALCULATION",
                            false,
                        )?;
                        match self.handle_udx_edxf_surcharge_calculation(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfMaterialBasis(values, fallback, None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.MATERIAL_BASIS",
                            false,
                        )?;
                        match self
                            .handle_udx_edxf_material_basis(helper, values, fallback, output)?
                        {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfMaterialBasisWeight(values, fallback, None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.MATERIAL_BASIS_WEIGHT",
                            false,
                        )?;
                        match self.handle_udx_edxf_material_basis_weight(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfMaterialBasisSurchargeThreshold(values, fallback, None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.MATERIAL_BASIS_SURCHARGE_THRESHOLD",
                            false,
                        )?;
                        match self.handle_udx_edxf_material_basis_surcharge_threshold(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfMaterialBasisSurchargeShutter(values, fallback, None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.MATERIAL_BASIS_SURCHARGE_SHUTTER",
                            false,
                        )?;
                        match self.handle_udx_edxf_material_basis_surcharge_shutter(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfMaterialBasisSurchargeCredit(values, fallback, None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.MATERIAL_BASIS_SURCHARGE_CREDIT",
                            false,
                        )?;
                        match self.handle_udx_edxf_material_basis_surcharge_credit(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (
                        S::UdxEdxfMaterialBasisSurchargeTable(values, fallback, None),
                        event @ (Event::Start(_) | Event::Empty(_)),
                    ) => {
                        let output = helper.init_start_tag_deserializer(
                            event,
                            Some(&super::NS_UNNAMED_5),
                            b"UDX.EDXF.MATERIAL_BASIS_SURCHARGE_TABLE",
                            false,
                        )?;
                        match self.handle_udx_edxf_material_basis_surcharge_table(
                            helper, values, fallback, output,
                        )? {
                            ElementHandlerOutput::Break { event, allow_any } => {
                                break (event, allow_any)
                            }
                            ElementHandlerOutput::Continue { event, .. } => event,
                        }
                    }
                    (state @ S::Done__(_), event) => {
                        *self.state__ = state;
                        break (DeserializerEvent::Continue(event), false);
                    }
                    (state, event) => {
                        *self.state__ = state;
                        break (DeserializerEvent::Continue(event), false);
                    }
                }
            };
            let artifact = if matches!(&*self.state__, S::Done__(_)) {
                DeserializerArtifact::Data(self.finish(helper)?)
            } else {
                DeserializerArtifact::Deserializer(self)
            };
            Ok(DeserializerOutput {
                artifact,
                event,
                allow_any,
            })
        }
        fn finish(
            self,
            helper: &mut DeserializeHelper,
        ) -> Result<super::UdxEdxfSurchargeElementTypeContent, Error> {
            Self::finish_state(helper, *self.state__)
        }
    }
}
pub mod quick_xml_serialize {
    use xsd_parser_types::quick_xml::{
        BytesEnd, BytesStart, Error, Event, IterSerializer, SerializeHelper, Serializer,
        WithSerializer,
    };
    #[derive(Debug)]
    pub struct BmecatElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::BmecatElementType,
        pub(super) state: Box<BmecatElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum BmecatElementTypeSerializerState<'ser> {
        Init__,
        Content__(
            IterSerializer<
                'ser,
                &'ser [super::BmecatElementTypeContent],
                super::BmecatElementTypeContent,
            >,
        ),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> BmecatElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    BmecatElementTypeSerializerState::Init__ => {
                        *self.state = BmecatElementTypeSerializerState::Content__(
                            IterSerializer::new(&self.value.content[..], None, false),
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib(&mut bytes, "version", &self.value.version)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    BmecatElementTypeSerializerState::Content__(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = BmecatElementTypeSerializerState::End__,
                        }
                    }
                    BmecatElementTypeSerializerState::End__ => {
                        *self.state = BmecatElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    BmecatElementTypeSerializerState::Done__ => return Ok(None),
                    BmecatElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for BmecatElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = BmecatElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct BmecatElementTypeContentSerializer<'ser> {
        pub(super) value: &'ser super::BmecatElementTypeContent,
        pub(super) state: Box<BmecatElementTypeContentSerializerState<'ser>>,
    }
    #[derive(Debug)]
    pub(super) enum BmecatElementTypeContentSerializerState<'ser> {
        Init__,
        Header(<super::HeaderElementType as WithSerializer>::Serializer<'ser>),
        TNewCatalog(<super::TNewCatalogElementType as WithSerializer>::Serializer<'ser>),
        TUpdateProducts(<super::TUpdateProductsElementType as WithSerializer>::Serializer<'ser>),
        TUpdatePrices(<super::TUpdatePricesElementType as WithSerializer>::Serializer<'ser>),
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> BmecatElementTypeContentSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    BmecatElementTypeContentSerializerState::Init__ => match self.value {
                        super::BmecatElementTypeContent::Header(x) => {
                            *self.state = BmecatElementTypeContentSerializerState::Header(
                                WithSerializer::serializer(x, Some("HEADER"), false)?,
                            )
                        }
                        super::BmecatElementTypeContent::TNewCatalog(x) => {
                            *self.state = BmecatElementTypeContentSerializerState::TNewCatalog(
                                WithSerializer::serializer(x, Some("T_NEW_CATALOG"), false)?,
                            )
                        }
                        super::BmecatElementTypeContent::TUpdateProducts(x) => {
                            *self.state = BmecatElementTypeContentSerializerState::TUpdateProducts(
                                WithSerializer::serializer(x, Some("T_UPDATE_PRODUCTS"), false)?,
                            )
                        }
                        super::BmecatElementTypeContent::TUpdatePrices(x) => {
                            *self.state = BmecatElementTypeContentSerializerState::TUpdatePrices(
                                WithSerializer::serializer(x, Some("T_UPDATE_PRICES"), false)?,
                            )
                        }
                    },
                    BmecatElementTypeContentSerializerState::Header(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = BmecatElementTypeContentSerializerState::Done__,
                        }
                    }
                    BmecatElementTypeContentSerializerState::TNewCatalog(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = BmecatElementTypeContentSerializerState::Done__,
                        }
                    }
                    BmecatElementTypeContentSerializerState::TUpdateProducts(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = BmecatElementTypeContentSerializerState::Done__,
                        }
                    }
                    BmecatElementTypeContentSerializerState::TUpdatePrices(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = BmecatElementTypeContentSerializerState::Done__,
                        }
                    }
                    BmecatElementTypeContentSerializerState::Done__ => return Ok(None),
                    BmecatElementTypeContentSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for BmecatElementTypeContentSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = BmecatElementTypeContentSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct HeaderElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::HeaderElementType,
        pub(super) state: Box<HeaderElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum HeaderElementTypeSerializerState<'ser> {
        Init__,
        GeneratorInfo(IterSerializer<'ser, Option<&'ser String>, String>),
        Catalog(<super::CatalogElementType as WithSerializer>::Serializer<'ser>),
        Buyer(<super::BuyerElementType as WithSerializer>::Serializer<'ser>),
        Supplier(<super::SupplierElementType as WithSerializer>::Serializer<'ser>),
        UserDefinedExtensions(<super::UdxHeader as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> HeaderElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    HeaderElementTypeSerializerState::Init__ => {
                        *self.state =
                            HeaderElementTypeSerializerState::GeneratorInfo(IterSerializer::new(
                                self.value.generator_info.as_ref(),
                                Some("GENERATOR_INFO"),
                                false,
                            ));
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    HeaderElementTypeSerializerState::GeneratorInfo(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = HeaderElementTypeSerializerState::Catalog(
                                    WithSerializer::serializer(
                                        &self.value.catalog,
                                        Some("CATALOG"),
                                        false,
                                    )?,
                                )
                            }
                        }
                    }
                    HeaderElementTypeSerializerState::Catalog(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = HeaderElementTypeSerializerState::Buyer(
                                    WithSerializer::serializer(
                                        &self.value.buyer,
                                        Some("BUYER"),
                                        false,
                                    )?,
                                )
                            }
                        }
                    }
                    HeaderElementTypeSerializerState::Buyer(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = HeaderElementTypeSerializerState::Supplier(
                                    WithSerializer::serializer(
                                        &self.value.supplier,
                                        Some("SUPPLIER"),
                                        false,
                                    )?,
                                )
                            }
                        }
                    }
                    HeaderElementTypeSerializerState::Supplier(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    HeaderElementTypeSerializerState::UserDefinedExtensions(
                                        WithSerializer::serializer(
                                            &self.value.user_defined_extensions,
                                            Some("USER_DEFINED_EXTENSIONS"),
                                            false,
                                        )?,
                                    )
                            }
                        }
                    }
                    HeaderElementTypeSerializerState::UserDefinedExtensions(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = HeaderElementTypeSerializerState::End__,
                        }
                    }
                    HeaderElementTypeSerializerState::End__ => {
                        *self.state = HeaderElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    HeaderElementTypeSerializerState::Done__ => return Ok(None),
                    HeaderElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for HeaderElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = HeaderElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct TNewCatalogElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::TNewCatalogElementType,
        pub(super) state: Box<TNewCatalogElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum TNewCatalogElementTypeSerializerState<'ser> {
        Init__,
        Product(
            IterSerializer<
                'ser,
                &'ser [super::TNewCatalogProductElementType],
                super::TNewCatalogProductElementType,
            >,
        ),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> TNewCatalogElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    TNewCatalogElementTypeSerializerState::Init__ => {
                        *self.state = TNewCatalogElementTypeSerializerState::Product(
                            IterSerializer::new(&self.value.product[..], Some("PRODUCT"), false),
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    TNewCatalogElementTypeSerializerState::Product(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = TNewCatalogElementTypeSerializerState::End__,
                        }
                    }
                    TNewCatalogElementTypeSerializerState::End__ => {
                        *self.state = TNewCatalogElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    TNewCatalogElementTypeSerializerState::Done__ => return Ok(None),
                    TNewCatalogElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for TNewCatalogElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = TNewCatalogElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct TUpdateProductsElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::TUpdateProductsElementType,
        pub(super) state: Box<TUpdateProductsElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum TUpdateProductsElementTypeSerializerState<'ser> {
        Init__,
        Product(
            IterSerializer<
                'ser,
                &'ser [super::TUpdateProductsProductElementType],
                super::TUpdateProductsProductElementType,
            >,
        ),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> TUpdateProductsElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    TUpdateProductsElementTypeSerializerState::Init__ => {
                        *self.state = TUpdateProductsElementTypeSerializerState::Product(
                            IterSerializer::new(&self.value.product[..], Some("PRODUCT"), false),
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib(
                            &mut bytes,
                            "prev_version",
                            &self.value.prev_version,
                        )?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    TUpdateProductsElementTypeSerializerState::Product(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = TUpdateProductsElementTypeSerializerState::End__,
                        }
                    }
                    TUpdateProductsElementTypeSerializerState::End__ => {
                        *self.state = TUpdateProductsElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    TUpdateProductsElementTypeSerializerState::Done__ => return Ok(None),
                    TUpdateProductsElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for TUpdateProductsElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = TUpdateProductsElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct TUpdatePricesElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::TUpdatePricesElementType,
        pub(super) state: Box<TUpdatePricesElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum TUpdatePricesElementTypeSerializerState<'ser> {
        Init__,
        Product(
            IterSerializer<
                'ser,
                &'ser [super::TUpdatePricesProductElementType],
                super::TUpdatePricesProductElementType,
            >,
        ),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> TUpdatePricesElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    TUpdatePricesElementTypeSerializerState::Init__ => {
                        *self.state = TUpdatePricesElementTypeSerializerState::Product(
                            IterSerializer::new(&self.value.product[..], Some("PRODUCT"), false),
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib(
                            &mut bytes,
                            "prev_version",
                            &self.value.prev_version,
                        )?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    TUpdatePricesElementTypeSerializerState::Product(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = TUpdatePricesElementTypeSerializerState::End__,
                        }
                    }
                    TUpdatePricesElementTypeSerializerState::End__ => {
                        *self.state = TUpdatePricesElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    TUpdatePricesElementTypeSerializerState::Done__ => return Ok(None),
                    TUpdatePricesElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for TUpdatePricesElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = TUpdatePricesElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct CatalogElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::CatalogElementType,
        pub(super) state: Box<CatalogElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum CatalogElementTypeSerializerState<'ser> {
        Init__,
        Language(
            IterSerializer<'ser, &'ser [super::LanguageElementType], super::LanguageElementType>,
        ),
        CatalogId(<String as WithSerializer>::Serializer<'ser>),
        CatalogVersion(<String as WithSerializer>::Serializer<'ser>),
        CatalogName(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        Datetime(<super::CatalogDatetimeElementType as WithSerializer>::Serializer<'ser>),
        Territory(IterSerializer<'ser, &'ser [String], String>),
        Currency(IterSerializer<'ser, Option<&'ser super::DtCurrencies>, super::DtCurrencies>),
        MimeRoot(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> CatalogElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    CatalogElementTypeSerializerState::Init__ => {
                        *self.state = CatalogElementTypeSerializerState::Language(
                            IterSerializer::new(&self.value.language[..], Some("LANGUAGE"), false),
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    CatalogElementTypeSerializerState::Language(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = CatalogElementTypeSerializerState::CatalogId(
                                    WithSerializer::serializer(
                                        &self.value.catalog_id,
                                        Some("CATALOG_ID"),
                                        false,
                                    )?,
                                )
                            }
                        }
                    }
                    CatalogElementTypeSerializerState::CatalogId(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = CatalogElementTypeSerializerState::CatalogVersion(
                                    WithSerializer::serializer(
                                        &self.value.catalog_version,
                                        Some("CATALOG_VERSION"),
                                        false,
                                    )?,
                                )
                            }
                        }
                    }
                    CatalogElementTypeSerializerState::CatalogVersion(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = CatalogElementTypeSerializerState::CatalogName(
                                    IterSerializer::new(
                                        &self.value.catalog_name[..],
                                        Some("CATALOG_NAME"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    CatalogElementTypeSerializerState::CatalogName(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = CatalogElementTypeSerializerState::Datetime(
                                    WithSerializer::serializer(
                                        &self.value.datetime,
                                        Some("DATETIME"),
                                        false,
                                    )?,
                                )
                            }
                        }
                    }
                    CatalogElementTypeSerializerState::Datetime(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = CatalogElementTypeSerializerState::Territory(
                                    IterSerializer::new(
                                        &self.value.territory[..],
                                        Some("TERRITORY"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    CatalogElementTypeSerializerState::Territory(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = CatalogElementTypeSerializerState::Currency(
                                    IterSerializer::new(
                                        self.value.currency.as_ref(),
                                        Some("CURRENCY"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    CatalogElementTypeSerializerState::Currency(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = CatalogElementTypeSerializerState::MimeRoot(
                                    IterSerializer::new(
                                        &self.value.mime_root[..],
                                        Some("MIME_ROOT"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    CatalogElementTypeSerializerState::MimeRoot(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = CatalogElementTypeSerializerState::End__,
                        }
                    }
                    CatalogElementTypeSerializerState::End__ => {
                        *self.state = CatalogElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    CatalogElementTypeSerializerState::Done__ => return Ok(None),
                    CatalogElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for CatalogElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = CatalogElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct BuyerElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::BuyerElementType,
        pub(super) state: Box<BuyerElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum BuyerElementTypeSerializerState<'ser> {
        Init__,
        BuyerId(IterSerializer<'ser, Option<&'ser super::TypePartyId>, super::TypePartyId>),
        BuyerName(<String as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> BuyerElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    BuyerElementTypeSerializerState::Init__ => {
                        *self.state =
                            BuyerElementTypeSerializerState::BuyerId(IterSerializer::new(
                                self.value.buyer_id.as_ref(),
                                Some("BUYER_ID"),
                                false,
                            ));
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    BuyerElementTypeSerializerState::BuyerId(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = BuyerElementTypeSerializerState::BuyerName(
                                    WithSerializer::serializer(
                                        &self.value.buyer_name,
                                        Some("BUYER_NAME"),
                                        false,
                                    )?,
                                )
                            }
                        }
                    }
                    BuyerElementTypeSerializerState::BuyerName(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = BuyerElementTypeSerializerState::End__,
                        }
                    }
                    BuyerElementTypeSerializerState::End__ => {
                        *self.state = BuyerElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    BuyerElementTypeSerializerState::Done__ => return Ok(None),
                    BuyerElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for BuyerElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = BuyerElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct SupplierElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::SupplierElementType,
        pub(super) state: Box<SupplierElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum SupplierElementTypeSerializerState<'ser> {
        Init__,
        SupplierId(IterSerializer<'ser, &'ser [super::TypePartyId], super::TypePartyId>),
        SupplierName(<String as WithSerializer>::Serializer<'ser>),
        Address(
            IterSerializer<
                'ser,
                Option<&'ser super::SupplierAddressElementType>,
                super::SupplierAddressElementType,
            >,
        ),
        MimeInfo(
            IterSerializer<
                'ser,
                Option<&'ser super::MimeInfoElementType>,
                super::MimeInfoElementType,
            >,
        ),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> SupplierElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    SupplierElementTypeSerializerState::Init__ => {
                        *self.state =
                            SupplierElementTypeSerializerState::SupplierId(IterSerializer::new(
                                &self.value.supplier_id[..],
                                Some("SUPPLIER_ID"),
                                false,
                            ));
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    SupplierElementTypeSerializerState::SupplierId(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = SupplierElementTypeSerializerState::SupplierName(
                                    WithSerializer::serializer(
                                        &self.value.supplier_name,
                                        Some("SUPPLIER_NAME"),
                                        false,
                                    )?,
                                )
                            }
                        }
                    }
                    SupplierElementTypeSerializerState::SupplierName(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = SupplierElementTypeSerializerState::Address(
                                    IterSerializer::new(
                                        self.value.address.as_ref(),
                                        Some("ADDRESS"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    SupplierElementTypeSerializerState::Address(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = SupplierElementTypeSerializerState::MimeInfo(
                                    IterSerializer::new(
                                        self.value.mime_info.as_ref(),
                                        Some("MIME_INFO"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    SupplierElementTypeSerializerState::MimeInfo(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = SupplierElementTypeSerializerState::End__,
                        }
                    }
                    SupplierElementTypeSerializerState::End__ => {
                        *self.state = SupplierElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    SupplierElementTypeSerializerState::Done__ => return Ok(None),
                    SupplierElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for SupplierElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = SupplierElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct UdxHeaderSerializer<'ser> {
        pub(super) value: &'ser super::UdxHeader,
        pub(super) state: Box<UdxHeaderSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum UdxHeaderSerializerState<'ser> {
        Init__,
        UdxEdxfVersion(<String as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> UdxHeaderSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    UdxHeaderSerializerState::Init__ => {
                        *self.state =
                            UdxHeaderSerializerState::UdxEdxfVersion(WithSerializer::serializer(
                                &self.value.udx_edxf_version,
                                Some("UDX.EDXF.VERSION"),
                                false,
                            )?);
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    UdxHeaderSerializerState::UdxEdxfVersion(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = UdxHeaderSerializerState::End__,
                        }
                    }
                    UdxHeaderSerializerState::End__ => {
                        *self.state = UdxHeaderSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    UdxHeaderSerializerState::Done__ => return Ok(None),
                    UdxHeaderSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for UdxHeaderSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = UdxHeaderSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct TNewCatalogProductElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::TNewCatalogProductElementType,
        pub(super) state: Box<TNewCatalogProductElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum TNewCatalogProductElementTypeSerializerState<'ser> {
        Init__,
        SupplierPid(<super::SupplierPidElementType as WithSerializer>::Serializer<'ser>),
        ProductDetails(<super::ProductDetailsElementType as WithSerializer>::Serializer<'ser>),
        ProductFeatures(
            IterSerializer<
                'ser,
                &'ser [super::ProductFeaturesElementType],
                super::ProductFeaturesElementType,
            >,
        ),
        ProductOrderDetails(
            <super::ProductOrderDetailsElementType as WithSerializer>::Serializer<'ser>,
        ),
        ProductPriceDetails(
            IterSerializer<
                'ser,
                &'ser [super::ProductPriceDetailsElementType],
                super::ProductPriceDetailsElementType,
            >,
        ),
        MimeInfo(
            IterSerializer<
                'ser,
                Option<&'ser super::MimeInfoElementType>,
                super::MimeInfoElementType,
            >,
        ),
        UserDefinedExtensions(<super::UdxProduct as WithSerializer>::Serializer<'ser>),
        ProductReference(
            IterSerializer<
                'ser,
                &'ser [super::ProductReferenceElementType],
                super::ProductReferenceElementType,
            >,
        ),
        ProductLogisticDetails(
            IterSerializer<
                'ser,
                Option<&'ser super::ProductLogisticDetailsElementType>,
                super::ProductLogisticDetailsElementType,
            >,
        ),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> TNewCatalogProductElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    TNewCatalogProductElementTypeSerializerState::Init__ => {
                        *self.state = TNewCatalogProductElementTypeSerializerState::SupplierPid(
                            WithSerializer::serializer(
                                &self.value.supplier_pid,
                                Some("SUPPLIER_PID"),
                                false,
                            )?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib(&mut bytes, "mode", &self.value.mode)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    TNewCatalogProductElementTypeSerializerState::SupplierPid(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    TNewCatalogProductElementTypeSerializerState::ProductDetails(
                                        WithSerializer::serializer(
                                            &self.value.product_details,
                                            Some("PRODUCT_DETAILS"),
                                            false,
                                        )?,
                                    )
                            }
                        }
                    }
                    TNewCatalogProductElementTypeSerializerState::ProductDetails(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    TNewCatalogProductElementTypeSerializerState::ProductFeatures(
                                        IterSerializer::new(
                                            &self.value.product_features[..],
                                            Some("PRODUCT_FEATURES"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    TNewCatalogProductElementTypeSerializerState::ProductFeatures(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state =
                                TNewCatalogProductElementTypeSerializerState::ProductOrderDetails(
                                    WithSerializer::serializer(
                                        &self.value.product_order_details,
                                        Some("PRODUCT_ORDER_DETAILS"),
                                        false,
                                    )?,
                                ),
                        }
                    }
                    TNewCatalogProductElementTypeSerializerState::ProductOrderDetails(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state =
                                TNewCatalogProductElementTypeSerializerState::ProductPriceDetails(
                                    IterSerializer::new(
                                        &self.value.product_price_details[..],
                                        Some("PRODUCT_PRICE_DETAILS"),
                                        false,
                                    ),
                                ),
                        }
                    }
                    TNewCatalogProductElementTypeSerializerState::ProductPriceDetails(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = TNewCatalogProductElementTypeSerializerState::MimeInfo(
                                    IterSerializer::new(
                                        self.value.mime_info.as_ref(),
                                        Some("MIME_INFO"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    TNewCatalogProductElementTypeSerializerState::MimeInfo(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state =
                                TNewCatalogProductElementTypeSerializerState::UserDefinedExtensions(
                                    WithSerializer::serializer(
                                        &self.value.user_defined_extensions,
                                        Some("USER_DEFINED_EXTENSIONS"),
                                        false,
                                    )?,
                                ),
                        }
                    }
                    TNewCatalogProductElementTypeSerializerState::UserDefinedExtensions(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    TNewCatalogProductElementTypeSerializerState::ProductReference(
                                        IterSerializer::new(
                                            &self.value.product_reference[..],
                                            Some("PRODUCT_REFERENCE"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    TNewCatalogProductElementTypeSerializerState::ProductReference(x) => match x
                        .next(helper)
                        .transpose()?
                    {
                        Some(event) => return Ok(Some(event)),
                        None => {
                            *self.state =
                                TNewCatalogProductElementTypeSerializerState::ProductLogisticDetails(
                                    IterSerializer::new(
                                        self.value.product_logistic_details.as_ref(),
                                        Some("PRODUCT_LOGISTIC_DETAILS"),
                                        false,
                                    ),
                                )
                        }
                    },
                    TNewCatalogProductElementTypeSerializerState::ProductLogisticDetails(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = TNewCatalogProductElementTypeSerializerState::End__
                            }
                        }
                    }
                    TNewCatalogProductElementTypeSerializerState::End__ => {
                        *self.state = TNewCatalogProductElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    TNewCatalogProductElementTypeSerializerState::Done__ => return Ok(None),
                    TNewCatalogProductElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for TNewCatalogProductElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = TNewCatalogProductElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct TUpdateProductsProductElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::TUpdateProductsProductElementType,
        pub(super) state: Box<TUpdateProductsProductElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum TUpdateProductsProductElementTypeSerializerState<'ser> {
        Init__,
        SupplierPid(<super::SupplierPidElementType as WithSerializer>::Serializer<'ser>),
        ProductDetails(<super::ProductDetailsElementType as WithSerializer>::Serializer<'ser>),
        ProductFeatures(
            IterSerializer<
                'ser,
                &'ser [super::ProductFeaturesElementType],
                super::ProductFeaturesElementType,
            >,
        ),
        ProductOrderDetails(
            <super::ProductOrderDetailsElementType as WithSerializer>::Serializer<'ser>,
        ),
        ProductPriceDetails(
            IterSerializer<
                'ser,
                &'ser [super::ProductPriceDetailsElementType],
                super::ProductPriceDetailsElementType,
            >,
        ),
        MimeInfo(
            IterSerializer<
                'ser,
                Option<&'ser super::MimeInfoElementType>,
                super::MimeInfoElementType,
            >,
        ),
        UserDefinedExtensions(
            IterSerializer<'ser, Option<&'ser super::UdxProduct>, super::UdxProduct>,
        ),
        ProductReference(
            IterSerializer<
                'ser,
                &'ser [super::ProductReferenceElementType],
                super::ProductReferenceElementType,
            >,
        ),
        ProductLogisticDetails(
            IterSerializer<
                'ser,
                Option<&'ser super::ProductLogisticDetailsElementType>,
                super::ProductLogisticDetailsElementType,
            >,
        ),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> TUpdateProductsProductElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match & mut * self . state { TUpdateProductsProductElementTypeSerializerState :: Init__ => { * self . state = TUpdateProductsProductElementTypeSerializerState :: SupplierPid (WithSerializer :: serializer (& self . value . supplier_pid , Some ("SUPPLIER_PID") , false) ?) ; let mut bytes = BytesStart :: new (self . name) ; helper . begin_ns_scope () ; helper . write_xmlns (& mut bytes , None , & super :: NS_UNNAMED_5) ; helper . write_attrib (& mut bytes , "mode" , & self . value . mode) ? ; return Ok (Some (Event :: Start (bytes))) } TUpdateProductsProductElementTypeSerializerState :: SupplierPid (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TUpdateProductsProductElementTypeSerializerState :: ProductDetails (WithSerializer :: serializer (& self . value . product_details , Some ("PRODUCT_DETAILS") , false) ?) , } TUpdateProductsProductElementTypeSerializerState :: ProductDetails (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TUpdateProductsProductElementTypeSerializerState :: ProductFeatures (IterSerializer :: new (& self . value . product_features [..] , Some ("PRODUCT_FEATURES") , false)) , } TUpdateProductsProductElementTypeSerializerState :: ProductFeatures (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TUpdateProductsProductElementTypeSerializerState :: ProductOrderDetails (WithSerializer :: serializer (& self . value . product_order_details , Some ("PRODUCT_ORDER_DETAILS") , false) ?) , } TUpdateProductsProductElementTypeSerializerState :: ProductOrderDetails (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TUpdateProductsProductElementTypeSerializerState :: ProductPriceDetails (IterSerializer :: new (& self . value . product_price_details [..] , Some ("PRODUCT_PRICE_DETAILS") , false)) , } TUpdateProductsProductElementTypeSerializerState :: ProductPriceDetails (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TUpdateProductsProductElementTypeSerializerState :: MimeInfo (IterSerializer :: new (self . value . mime_info . as_ref () , Some ("MIME_INFO") , false)) , } TUpdateProductsProductElementTypeSerializerState :: MimeInfo (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TUpdateProductsProductElementTypeSerializerState :: UserDefinedExtensions (IterSerializer :: new (self . value . user_defined_extensions . as_ref () , Some ("USER_DEFINED_EXTENSIONS") , false)) , } TUpdateProductsProductElementTypeSerializerState :: UserDefinedExtensions (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TUpdateProductsProductElementTypeSerializerState :: ProductReference (IterSerializer :: new (& self . value . product_reference [..] , Some ("PRODUCT_REFERENCE") , false)) , } TUpdateProductsProductElementTypeSerializerState :: ProductReference (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TUpdateProductsProductElementTypeSerializerState :: ProductLogisticDetails (IterSerializer :: new (self . value . product_logistic_details . as_ref () , Some ("PRODUCT_LOGISTIC_DETAILS") , false)) , } TUpdateProductsProductElementTypeSerializerState :: ProductLogisticDetails (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TUpdateProductsProductElementTypeSerializerState :: End__ , } TUpdateProductsProductElementTypeSerializerState :: End__ => { * self . state = TUpdateProductsProductElementTypeSerializerState :: Done__ ; helper . end_ns_scope () ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } TUpdateProductsProductElementTypeSerializerState :: Done__ => return Ok (None) , TUpdateProductsProductElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
            }
        }
    }
    impl<'ser> Serializer<'ser> for TUpdateProductsProductElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = TUpdateProductsProductElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct TUpdatePricesProductElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::TUpdatePricesProductElementType,
        pub(super) state: Box<TUpdatePricesProductElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum TUpdatePricesProductElementTypeSerializerState<'ser> {
        Init__,
        SupplierPid(<super::SupplierPidElementType as WithSerializer>::Serializer<'ser>),
        ProductPriceDetails(
            IterSerializer<
                'ser,
                &'ser [super::ProductPriceDetailsElementType],
                super::ProductPriceDetailsElementType,
            >,
        ),
        UserDefinedExtensions(
            IterSerializer<'ser, Option<&'ser super::UdxProduct>, super::UdxProduct>,
        ),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> TUpdatePricesProductElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match & mut * self . state { TUpdatePricesProductElementTypeSerializerState :: Init__ => { * self . state = TUpdatePricesProductElementTypeSerializerState :: SupplierPid (WithSerializer :: serializer (& self . value . supplier_pid , Some ("SUPPLIER_PID") , false) ?) ; let mut bytes = BytesStart :: new (self . name) ; helper . begin_ns_scope () ; helper . write_xmlns (& mut bytes , None , & super :: NS_UNNAMED_5) ; helper . write_attrib (& mut bytes , "mode" , & self . value . mode) ? ; return Ok (Some (Event :: Start (bytes))) } TUpdatePricesProductElementTypeSerializerState :: SupplierPid (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TUpdatePricesProductElementTypeSerializerState :: ProductPriceDetails (IterSerializer :: new (& self . value . product_price_details [..] , Some ("PRODUCT_PRICE_DETAILS") , false)) , } TUpdatePricesProductElementTypeSerializerState :: ProductPriceDetails (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TUpdatePricesProductElementTypeSerializerState :: UserDefinedExtensions (IterSerializer :: new (self . value . user_defined_extensions . as_ref () , Some ("USER_DEFINED_EXTENSIONS") , false)) , } TUpdatePricesProductElementTypeSerializerState :: UserDefinedExtensions (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = TUpdatePricesProductElementTypeSerializerState :: End__ , } TUpdatePricesProductElementTypeSerializerState :: End__ => { * self . state = TUpdatePricesProductElementTypeSerializerState :: Done__ ; helper . end_ns_scope () ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } TUpdatePricesProductElementTypeSerializerState :: Done__ => return Ok (None) , TUpdatePricesProductElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
            }
        }
    }
    impl<'ser> Serializer<'ser> for TUpdatePricesProductElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = TUpdatePricesProductElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct LanguageElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::LanguageElementType,
        pub(super) state: Box<LanguageElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum LanguageElementTypeSerializerState<'ser> {
        Init__,
        Content__(<super::DtLang as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> LanguageElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    LanguageElementTypeSerializerState::Init__ => {
                        *self.state = LanguageElementTypeSerializerState::Content__(
                            WithSerializer::serializer(&self.value.content, None, false)?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib_opt(&mut bytes, "default", &self.value.default)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    LanguageElementTypeSerializerState::Content__(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = LanguageElementTypeSerializerState::End__,
                        }
                    }
                    LanguageElementTypeSerializerState::End__ => {
                        *self.state = LanguageElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    LanguageElementTypeSerializerState::Done__ => return Ok(None),
                    LanguageElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for LanguageElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = LanguageElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct DtMlstringSerializer<'ser> {
        pub(super) value: &'ser super::DtMlstring,
        pub(super) state: Box<DtMlstringSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum DtMlstringSerializerState<'ser> {
        Init__,
        Content__(<String as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> DtMlstringSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    DtMlstringSerializerState::Init__ => {
                        *self.state = DtMlstringSerializerState::Content__(
                            WithSerializer::serializer(&self.value.content, None, false)?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib_opt(&mut bytes, "lang", &self.value.lang)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    DtMlstringSerializerState::Content__(x) => match x.next(helper).transpose()? {
                        Some(event) => return Ok(Some(event)),
                        None => *self.state = DtMlstringSerializerState::End__,
                    },
                    DtMlstringSerializerState::End__ => {
                        *self.state = DtMlstringSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    DtMlstringSerializerState::Done__ => return Ok(None),
                    DtMlstringSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for DtMlstringSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = DtMlstringSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct CatalogDatetimeElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::CatalogDatetimeElementType,
        pub(super) state: Box<CatalogDatetimeElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum CatalogDatetimeElementTypeSerializerState<'ser> {
        Init__,
        Date(<String as WithSerializer>::Serializer<'ser>),
        Time(IterSerializer<'ser, Option<&'ser String>, String>),
        Timezone(IterSerializer<'ser, Option<&'ser String>, String>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> CatalogDatetimeElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    CatalogDatetimeElementTypeSerializerState::Init__ => {
                        *self.state = CatalogDatetimeElementTypeSerializerState::Date(
                            WithSerializer::serializer(&self.value.date, Some("DATE"), false)?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib(&mut bytes, "type", &self.value.type_)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    CatalogDatetimeElementTypeSerializerState::Date(x) => match x
                        .next(helper)
                        .transpose()?
                    {
                        Some(event) => return Ok(Some(event)),
                        None => {
                            *self.state = CatalogDatetimeElementTypeSerializerState::Time(
                                IterSerializer::new(self.value.time.as_ref(), Some("TIME"), false),
                            )
                        }
                    },
                    CatalogDatetimeElementTypeSerializerState::Time(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = CatalogDatetimeElementTypeSerializerState::Timezone(
                                    IterSerializer::new(
                                        self.value.timezone.as_ref(),
                                        Some("TIMEZONE"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    CatalogDatetimeElementTypeSerializerState::Timezone(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = CatalogDatetimeElementTypeSerializerState::End__,
                        }
                    }
                    CatalogDatetimeElementTypeSerializerState::End__ => {
                        *self.state = CatalogDatetimeElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    CatalogDatetimeElementTypeSerializerState::Done__ => return Ok(None),
                    CatalogDatetimeElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for CatalogDatetimeElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = CatalogDatetimeElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct TypePartyIdSerializer<'ser> {
        pub(super) value: &'ser super::TypePartyId,
        pub(super) state: Box<TypePartyIdSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum TypePartyIdSerializerState<'ser> {
        Init__,
        Content__(<String as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> TypePartyIdSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    TypePartyIdSerializerState::Init__ => {
                        *self.state = TypePartyIdSerializerState::Content__(
                            WithSerializer::serializer(&self.value.content, None, false)?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib_opt(&mut bytes, "type", &self.value.type_)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    TypePartyIdSerializerState::Content__(x) => match x.next(helper).transpose()? {
                        Some(event) => return Ok(Some(event)),
                        None => *self.state = TypePartyIdSerializerState::End__,
                    },
                    TypePartyIdSerializerState::End__ => {
                        *self.state = TypePartyIdSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    TypePartyIdSerializerState::Done__ => return Ok(None),
                    TypePartyIdSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for TypePartyIdSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = TypePartyIdSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct SupplierAddressElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::SupplierAddressElementType,
        pub(super) state: Box<SupplierAddressElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum SupplierAddressElementTypeSerializerState<'ser> {
        Init__,
        Contact(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        Street(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        Zip(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        City(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        Country(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        VatId(IterSerializer<'ser, Option<&'ser String>, String>),
        Email(<String as WithSerializer>::Serializer<'ser>),
        Url(IterSerializer<'ser, Option<&'ser String>, String>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> SupplierAddressElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    SupplierAddressElementTypeSerializerState::Init__ => {
                        *self.state = SupplierAddressElementTypeSerializerState::Contact(
                            IterSerializer::new(&self.value.contact[..], Some("CONTACT"), false),
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib(&mut bytes, "type", &self.value.type_)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    SupplierAddressElementTypeSerializerState::Contact(x) => match x
                        .next(helper)
                        .transpose()?
                    {
                        Some(event) => return Ok(Some(event)),
                        None => {
                            *self.state = SupplierAddressElementTypeSerializerState::Street(
                                IterSerializer::new(&self.value.street[..], Some("STREET"), false),
                            )
                        }
                    },
                    SupplierAddressElementTypeSerializerState::Street(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = SupplierAddressElementTypeSerializerState::Zip(
                                    IterSerializer::new(&self.value.zip[..], Some("ZIP"), false),
                                )
                            }
                        }
                    }
                    SupplierAddressElementTypeSerializerState::Zip(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = SupplierAddressElementTypeSerializerState::City(
                                    IterSerializer::new(&self.value.city[..], Some("CITY"), false),
                                )
                            }
                        }
                    }
                    SupplierAddressElementTypeSerializerState::City(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = SupplierAddressElementTypeSerializerState::Country(
                                    IterSerializer::new(
                                        &self.value.country[..],
                                        Some("COUNTRY"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    SupplierAddressElementTypeSerializerState::Country(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = SupplierAddressElementTypeSerializerState::VatId(
                                    IterSerializer::new(
                                        self.value.vat_id.as_ref(),
                                        Some("VAT_ID"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    SupplierAddressElementTypeSerializerState::VatId(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = SupplierAddressElementTypeSerializerState::Email(
                                    WithSerializer::serializer(
                                        &self.value.email,
                                        Some("EMAIL"),
                                        false,
                                    )?,
                                )
                            }
                        }
                    }
                    SupplierAddressElementTypeSerializerState::Email(x) => match x
                        .next(helper)
                        .transpose()?
                    {
                        Some(event) => return Ok(Some(event)),
                        None => {
                            *self.state = SupplierAddressElementTypeSerializerState::Url(
                                IterSerializer::new(self.value.url.as_ref(), Some("URL"), false),
                            )
                        }
                    },
                    SupplierAddressElementTypeSerializerState::Url(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = SupplierAddressElementTypeSerializerState::End__,
                        }
                    }
                    SupplierAddressElementTypeSerializerState::End__ => {
                        *self.state = SupplierAddressElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    SupplierAddressElementTypeSerializerState::Done__ => return Ok(None),
                    SupplierAddressElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for SupplierAddressElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = SupplierAddressElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct MimeInfoElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::MimeInfoElementType,
        pub(super) state: Box<MimeInfoElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum MimeInfoElementTypeSerializerState<'ser> {
        Init__,
        Mime(IterSerializer<'ser, &'ser [super::MimeElementType], super::MimeElementType>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> MimeInfoElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    MimeInfoElementTypeSerializerState::Init__ => {
                        *self.state = MimeInfoElementTypeSerializerState::Mime(
                            IterSerializer::new(&self.value.mime[..], Some("MIME"), false),
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    MimeInfoElementTypeSerializerState::Mime(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = MimeInfoElementTypeSerializerState::End__,
                        }
                    }
                    MimeInfoElementTypeSerializerState::End__ => {
                        *self.state = MimeInfoElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    MimeInfoElementTypeSerializerState::Done__ => return Ok(None),
                    MimeInfoElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for MimeInfoElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = MimeInfoElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct SupplierPidElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::SupplierPidElementType,
        pub(super) state: Box<SupplierPidElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum SupplierPidElementTypeSerializerState<'ser> {
        Init__,
        Content__(<String as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> SupplierPidElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    SupplierPidElementTypeSerializerState::Init__ => {
                        *self.state = SupplierPidElementTypeSerializerState::Content__(
                            WithSerializer::serializer(&self.value.content, None, false)?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib_opt(&mut bytes, "type", &self.value.type_)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    SupplierPidElementTypeSerializerState::Content__(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = SupplierPidElementTypeSerializerState::End__,
                        }
                    }
                    SupplierPidElementTypeSerializerState::End__ => {
                        *self.state = SupplierPidElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    SupplierPidElementTypeSerializerState::Done__ => return Ok(None),
                    SupplierPidElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for SupplierPidElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = SupplierPidElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct ProductDetailsElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::ProductDetailsElementType,
        pub(super) state: Box<ProductDetailsElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum ProductDetailsElementTypeSerializerState<'ser> {
        Init__,
        DescriptionShort(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        DescriptionLong(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        InternationalPid(
            IterSerializer<
                'ser,
                &'ser [super::InternationalPidElementType],
                super::InternationalPidElementType,
            >,
        ),
        SupplierAltPid(IterSerializer<'ser, Option<&'ser String>, String>),
        BuyerPid(
            IterSerializer<'ser, &'ser [super::BuyerPidElementType], super::BuyerPidElementType>,
        ),
        ManufacturerPid(IterSerializer<'ser, Option<&'ser String>, String>),
        ManufacturerName(IterSerializer<'ser, Option<&'ser String>, String>),
        ManufacturerTypeDescr(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        SpecialTreatmentClass(
            IterSerializer<
                'ser,
                &'ser [super::SpecialTreatmentClassElementType],
                super::SpecialTreatmentClassElementType,
            >,
        ),
        Keyword(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        Remarks(IterSerializer<'ser, &'ser [super::RemarksElementType], super::RemarksElementType>),
        ProductStatus(
            IterSerializer<
                'ser,
                &'ser [super::ProductStatusElementType],
                super::ProductStatusElementType,
            >,
        ),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> ProductDetailsElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    ProductDetailsElementTypeSerializerState::Init__ => {
                        *self.state = ProductDetailsElementTypeSerializerState::DescriptionShort(
                            IterSerializer::new(
                                &self.value.description_short[..],
                                Some("DESCRIPTION_SHORT"),
                                false,
                            ),
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    ProductDetailsElementTypeSerializerState::DescriptionShort(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductDetailsElementTypeSerializerState::DescriptionLong(
                                        IterSerializer::new(
                                            &self.value.description_long[..],
                                            Some("DESCRIPTION_LONG"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    ProductDetailsElementTypeSerializerState::DescriptionLong(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductDetailsElementTypeSerializerState::InternationalPid(
                                        IterSerializer::new(
                                            &self.value.international_pid[..],
                                            Some("INTERNATIONAL_PID"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    ProductDetailsElementTypeSerializerState::InternationalPid(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductDetailsElementTypeSerializerState::SupplierAltPid(
                                        IterSerializer::new(
                                            self.value.supplier_alt_pid.as_ref(),
                                            Some("SUPPLIER_ALT_PID"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    ProductDetailsElementTypeSerializerState::SupplierAltPid(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = ProductDetailsElementTypeSerializerState::BuyerPid(
                                    IterSerializer::new(
                                        &self.value.buyer_pid[..],
                                        Some("BUYER_PID"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    ProductDetailsElementTypeSerializerState::BuyerPid(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductDetailsElementTypeSerializerState::ManufacturerPid(
                                        IterSerializer::new(
                                            self.value.manufacturer_pid.as_ref(),
                                            Some("MANUFACTURER_PID"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    ProductDetailsElementTypeSerializerState::ManufacturerPid(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductDetailsElementTypeSerializerState::ManufacturerName(
                                        IterSerializer::new(
                                            self.value.manufacturer_name.as_ref(),
                                            Some("MANUFACTURER_NAME"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    ProductDetailsElementTypeSerializerState::ManufacturerName(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductDetailsElementTypeSerializerState::ManufacturerTypeDescr(
                                        IterSerializer::new(
                                            &self.value.manufacturer_type_descr[..],
                                            Some("MANUFACTURER_TYPE_DESCR"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    ProductDetailsElementTypeSerializerState::ManufacturerTypeDescr(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductDetailsElementTypeSerializerState::SpecialTreatmentClass(
                                        IterSerializer::new(
                                            &self.value.special_treatment_class[..],
                                            Some("SPECIAL_TREATMENT_CLASS"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    ProductDetailsElementTypeSerializerState::SpecialTreatmentClass(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = ProductDetailsElementTypeSerializerState::Keyword(
                                    IterSerializer::new(
                                        &self.value.keyword[..],
                                        Some("KEYWORD"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    ProductDetailsElementTypeSerializerState::Keyword(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = ProductDetailsElementTypeSerializerState::Remarks(
                                    IterSerializer::new(
                                        &self.value.remarks[..],
                                        Some("REMARKS"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    ProductDetailsElementTypeSerializerState::Remarks(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductDetailsElementTypeSerializerState::ProductStatus(
                                        IterSerializer::new(
                                            &self.value.product_status[..],
                                            Some("PRODUCT_STATUS"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    ProductDetailsElementTypeSerializerState::ProductStatus(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = ProductDetailsElementTypeSerializerState::End__,
                        }
                    }
                    ProductDetailsElementTypeSerializerState::End__ => {
                        *self.state = ProductDetailsElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    ProductDetailsElementTypeSerializerState::Done__ => return Ok(None),
                    ProductDetailsElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for ProductDetailsElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = ProductDetailsElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct ProductFeaturesElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::ProductFeaturesElementType,
        pub(super) state: Box<ProductFeaturesElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum ProductFeaturesElementTypeSerializerState<'ser> {
        Init__,
        ReferenceFeatureSystemName(<String as WithSerializer>::Serializer<'ser>),
        ReferenceFeatureGroupId(
            <super::TypeClassificationGroupId as WithSerializer>::Serializer<'ser>,
        ),
        Feature(IterSerializer<'ser, &'ser [super::FeatureElementType], super::FeatureElementType>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> ProductFeaturesElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    ProductFeaturesElementTypeSerializerState::Init__ => {
                        *self.state =
                            ProductFeaturesElementTypeSerializerState::ReferenceFeatureSystemName(
                                WithSerializer::serializer(
                                    &self.value.reference_feature_system_name,
                                    Some("REFERENCE_FEATURE_SYSTEM_NAME"),
                                    false,
                                )?,
                            );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    ProductFeaturesElementTypeSerializerState::ReferenceFeatureSystemName(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state =
                                ProductFeaturesElementTypeSerializerState::ReferenceFeatureGroupId(
                                    WithSerializer::serializer(
                                        &self.value.reference_feature_group_id,
                                        Some("REFERENCE_FEATURE_GROUP_ID"),
                                        false,
                                    )?,
                                ),
                        }
                    }
                    ProductFeaturesElementTypeSerializerState::ReferenceFeatureGroupId(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = ProductFeaturesElementTypeSerializerState::Feature(
                                    IterSerializer::new(
                                        &self.value.feature[..],
                                        Some("FEATURE"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    ProductFeaturesElementTypeSerializerState::Feature(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = ProductFeaturesElementTypeSerializerState::End__,
                        }
                    }
                    ProductFeaturesElementTypeSerializerState::End__ => {
                        *self.state = ProductFeaturesElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    ProductFeaturesElementTypeSerializerState::Done__ => return Ok(None),
                    ProductFeaturesElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for ProductFeaturesElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = ProductFeaturesElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct ProductOrderDetailsElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::ProductOrderDetailsElementType,
        pub(super) state: Box<ProductOrderDetailsElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum ProductOrderDetailsElementTypeSerializerState<'ser> {
        Init__,
        OrderUnit(<super::DtPunit as WithSerializer>::Serializer<'ser>),
        ContentUnit(<super::DtPunit as WithSerializer>::Serializer<'ser>),
        NoCuPerOu(IterSerializer<'ser, Option<&'ser f64>, f64>),
        PriceQuantity(IterSerializer<'ser, Option<&'ser f64>, f64>),
        QuantityMin(IterSerializer<'ser, Option<&'ser f32>, f32>),
        QuantityInterval(IterSerializer<'ser, Option<&'ser f32>, f32>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> ProductOrderDetailsElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    ProductOrderDetailsElementTypeSerializerState::Init__ => {
                        *self.state = ProductOrderDetailsElementTypeSerializerState::OrderUnit(
                            WithSerializer::serializer(
                                &self.value.order_unit,
                                Some("ORDER_UNIT"),
                                false,
                            )?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    ProductOrderDetailsElementTypeSerializerState::OrderUnit(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductOrderDetailsElementTypeSerializerState::ContentUnit(
                                        WithSerializer::serializer(
                                            &self.value.content_unit,
                                            Some("CONTENT_UNIT"),
                                            false,
                                        )?,
                                    )
                            }
                        }
                    }
                    ProductOrderDetailsElementTypeSerializerState::ContentUnit(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductOrderDetailsElementTypeSerializerState::NoCuPerOu(
                                        IterSerializer::new(
                                            self.value.no_cu_per_ou.as_ref(),
                                            Some("NO_CU_PER_OU"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    ProductOrderDetailsElementTypeSerializerState::NoCuPerOu(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductOrderDetailsElementTypeSerializerState::PriceQuantity(
                                        IterSerializer::new(
                                            self.value.price_quantity.as_ref(),
                                            Some("PRICE_QUANTITY"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    ProductOrderDetailsElementTypeSerializerState::PriceQuantity(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductOrderDetailsElementTypeSerializerState::QuantityMin(
                                        IterSerializer::new(
                                            self.value.quantity_min.as_ref(),
                                            Some("QUANTITY_MIN"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    ProductOrderDetailsElementTypeSerializerState::QuantityMin(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductOrderDetailsElementTypeSerializerState::QuantityInterval(
                                        IterSerializer::new(
                                            self.value.quantity_interval.as_ref(),
                                            Some("QUANTITY_INTERVAL"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    ProductOrderDetailsElementTypeSerializerState::QuantityInterval(x) => match x
                        .next(helper)
                        .transpose()?
                    {
                        Some(event) => return Ok(Some(event)),
                        None => *self.state = ProductOrderDetailsElementTypeSerializerState::End__,
                    },
                    ProductOrderDetailsElementTypeSerializerState::End__ => {
                        *self.state = ProductOrderDetailsElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    ProductOrderDetailsElementTypeSerializerState::Done__ => return Ok(None),
                    ProductOrderDetailsElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for ProductOrderDetailsElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = ProductOrderDetailsElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct ProductPriceDetailsElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::ProductPriceDetailsElementType,
        pub(super) state: Box<ProductPriceDetailsElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum ProductPriceDetailsElementTypeSerializerState<'ser> {
        Init__,
        Datetime(
            IterSerializer<
                'ser,
                &'ser [super::ProductPriceDetailsDatetimeElementType],
                super::ProductPriceDetailsDatetimeElementType,
            >,
        ),
        DailyPrice(IterSerializer<'ser, Option<&'ser String>, String>),
        ProductPrice(
            IterSerializer<
                'ser,
                &'ser [super::ProductPriceElementType],
                super::ProductPriceElementType,
            >,
        ),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> ProductPriceDetailsElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    ProductPriceDetailsElementTypeSerializerState::Init__ => {
                        *self.state = ProductPriceDetailsElementTypeSerializerState::Datetime(
                            IterSerializer::new(&self.value.datetime[..], Some("DATETIME"), false),
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    ProductPriceDetailsElementTypeSerializerState::Datetime(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductPriceDetailsElementTypeSerializerState::DailyPrice(
                                        IterSerializer::new(
                                            self.value.daily_price.as_ref(),
                                            Some("DAILY_PRICE"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    ProductPriceDetailsElementTypeSerializerState::DailyPrice(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductPriceDetailsElementTypeSerializerState::ProductPrice(
                                        IterSerializer::new(
                                            &self.value.product_price[..],
                                            Some("PRODUCT_PRICE"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    ProductPriceDetailsElementTypeSerializerState::ProductPrice(x) => match x
                        .next(helper)
                        .transpose()?
                    {
                        Some(event) => return Ok(Some(event)),
                        None => *self.state = ProductPriceDetailsElementTypeSerializerState::End__,
                    },
                    ProductPriceDetailsElementTypeSerializerState::End__ => {
                        *self.state = ProductPriceDetailsElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    ProductPriceDetailsElementTypeSerializerState::Done__ => return Ok(None),
                    ProductPriceDetailsElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for ProductPriceDetailsElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = ProductPriceDetailsElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct UdxProductSerializer<'ser> {
        pub(super) value: &'ser super::UdxProduct,
        pub(super) state: Box<UdxProductSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum UdxProductSerializerState<'ser> {
        Init__,
        UdxEdxfManufacturerAcronym(IterSerializer<'ser, Option<&'ser String>, String>),
        UdxEdxfDescriptionVeryShort(
            IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>,
        ),
        UdxEdxfBrandName(IterSerializer<'ser, Option<&'ser String>, String>),
        UdxEdxfTenderText(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        UdxEdxfValidFrom(IterSerializer<'ser, Option<&'ser String>, String>),
        UdxEdxfExpirationDate(IterSerializer<'ser, Option<&'ser String>, String>),
        UdxEdxfDiscountGroup(
            IterSerializer<
                'ser,
                Option<&'ser super::UdxEdxfDiscountGroupElementType>,
                super::UdxEdxfDiscountGroupElementType,
            >,
        ),
        UdxEdxfBonusGroupSupplier(IterSerializer<'ser, Option<&'ser String>, String>),
        UdxEdxfPkwiu(IterSerializer<'ser, Option<&'ser String>, String>),
        UdxEdxfDeclaration(
            IterSerializer<
                'ser,
                &'ser [super::UdxEdxfDeclarationElementType],
                super::UdxEdxfDeclarationElementType,
            >,
        ),
        UdxEdxfAdditionalFactors(
            IterSerializer<
                'ser,
                Option<&'ser super::UdxEdxfAdditionalFactorsElementType>,
                super::UdxEdxfAdditionalFactorsElementType,
            >,
        ),
        UdxEdxfProductToStock(IterSerializer<'ser, Option<&'ser String>, String>),
        UdxEdxfProductSeries(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        UdxEdxfProductVariation(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        UdxEdxfAtReverseChargeInfo(IterSerializer<'ser, Option<&'ser String>, String>),
        UdxEdxfCountryBranchNumbers(
            IterSerializer<
                'ser,
                Option<&'ser super::UdxEdxfCountryBranchNumbersElementType>,
                super::UdxEdxfCountryBranchNumbersElementType,
            >,
        ),
        UdxEdxfCountryBranchSupplierIds(
            IterSerializer<
                'ser,
                Option<&'ser super::UdxEdxfCountryBranchSupplierIdsElementType>,
                super::UdxEdxfCountryBranchSupplierIdsElementType,
            >,
        ),
        UdxEdxfPackingUnits(
            IterSerializer<
                'ser,
                Option<&'ser super::UdxEdxfPackingUnitsElementType>,
                super::UdxEdxfPackingUnitsElementType,
            >,
        ),
        UdxEdxfProductLogisticDetails(
            IterSerializer<
                'ser,
                Option<&'ser super::UdxEdxfProductLogisticDetailsElementType>,
                super::UdxEdxfProductLogisticDetailsElementType,
            >,
        ),
        UdxEdxfReach(
            IterSerializer<
                'ser,
                Option<&'ser super::UdxEdxfReachElementType>,
                super::UdxEdxfReachElementType,
            >,
        ),
        UdxEdxfSurchargeList(
            IterSerializer<
                'ser,
                Option<&'ser super::UdxEdxfSurchargeListElementType>,
                super::UdxEdxfSurchargeListElementType,
            >,
        ),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> UdxProductSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    UdxProductSerializerState::Init__ => {
                        *self.state = UdxProductSerializerState::UdxEdxfManufacturerAcronym(
                            IterSerializer::new(
                                self.value.udx_edxf_manufacturer_acronym.as_ref(),
                                Some("UDX.EDXF.MANUFACTURER_ACRONYM"),
                                false,
                            ),
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    UdxProductSerializerState::UdxEdxfManufacturerAcronym(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = UdxProductSerializerState::UdxEdxfDescriptionVeryShort(
                                    IterSerializer::new(
                                        &self.value.udx_edxf_description_very_short[..],
                                        Some("UDX.EDXF.DESCRIPTION_VERY_SHORT"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfDescriptionVeryShort(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = UdxProductSerializerState::UdxEdxfBrandName(
                                    IterSerializer::new(
                                        self.value.udx_edxf_brand_name.as_ref(),
                                        Some("UDX.EDXF.BRAND_NAME"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfBrandName(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = UdxProductSerializerState::UdxEdxfTenderText(
                                    IterSerializer::new(
                                        &self.value.udx_edxf_tender_text[..],
                                        Some("UDX.EDXF.TENDER_TEXT"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfTenderText(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = UdxProductSerializerState::UdxEdxfValidFrom(
                                    IterSerializer::new(
                                        self.value.udx_edxf_valid_from.as_ref(),
                                        Some("UDX.EDXF.VALID_FROM"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfValidFrom(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = UdxProductSerializerState::UdxEdxfExpirationDate(
                                    IterSerializer::new(
                                        self.value.udx_edxf_expiration_date.as_ref(),
                                        Some("UDX.EDXF.EXPIRATION_DATE"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfExpirationDate(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = UdxProductSerializerState::UdxEdxfDiscountGroup(
                                    IterSerializer::new(
                                        self.value.udx_edxf_discount_group.as_ref(),
                                        Some("UDX.EDXF.DISCOUNT_GROUP"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfDiscountGroup(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = UdxProductSerializerState::UdxEdxfBonusGroupSupplier(
                                    IterSerializer::new(
                                        self.value.udx_edxf_bonus_group_supplier.as_ref(),
                                        Some("UDX.EDXF.BONUS_GROUP_SUPPLIER"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfBonusGroupSupplier(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    UdxProductSerializerState::UdxEdxfPkwiu(IterSerializer::new(
                                        self.value.udx_edxf_pkwiu.as_ref(),
                                        Some("UDX.EDXF.PKWIU"),
                                        false,
                                    ))
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfPkwiu(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = UdxProductSerializerState::UdxEdxfDeclaration(
                                    IterSerializer::new(
                                        &self.value.udx_edxf_declaration[..],
                                        Some("UDX.EDXF.DECLARATION"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfDeclaration(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = UdxProductSerializerState::UdxEdxfAdditionalFactors(
                                    IterSerializer::new(
                                        self.value.udx_edxf_additional_factors.as_ref(),
                                        Some("UDX.EDXF.ADDITIONAL_FACTORS"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfAdditionalFactors(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = UdxProductSerializerState::UdxEdxfProductToStock(
                                    IterSerializer::new(
                                        self.value.udx_edxf_product_to_stock.as_ref(),
                                        Some("UDX.EDXF.PRODUCT_TO_STOCK"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfProductToStock(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = UdxProductSerializerState::UdxEdxfProductSeries(
                                    IterSerializer::new(
                                        &self.value.udx_edxf_product_series[..],
                                        Some("UDX.EDXF.PRODUCT_SERIES"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfProductSeries(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = UdxProductSerializerState::UdxEdxfProductVariation(
                                    IterSerializer::new(
                                        &self.value.udx_edxf_product_variation[..],
                                        Some("UDX.EDXF.PRODUCT_VARIATION"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfProductVariation(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = UdxProductSerializerState::UdxEdxfAtReverseChargeInfo(
                                    IterSerializer::new(
                                        self.value.udx_edxf_at_reverse_charge_info.as_ref(),
                                        Some("UDX.EDXF.AT.REVERSE_CHARGE_INFO"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfAtReverseChargeInfo(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = UdxProductSerializerState::UdxEdxfCountryBranchNumbers(
                                    IterSerializer::new(
                                        self.value.udx_edxf_country_branch_numbers.as_ref(),
                                        Some("UDX.EDXF.COUNTRY_BRANCH_NUMBERS"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfCountryBranchNumbers(x) => match x
                        .next(helper)
                        .transpose()?
                    {
                        Some(event) => return Ok(Some(event)),
                        None => {
                            *self.state = UdxProductSerializerState::UdxEdxfCountryBranchSupplierIds(
                                IterSerializer::new(
                                    self.value.udx_edxf_country_branch_supplier_ids.as_ref(),
                                    Some("UDX.EDXF.COUNTRY_BRANCH_SUPPLIER_IDS"),
                                    false,
                                ),
                            )
                        }
                    },
                    UdxProductSerializerState::UdxEdxfCountryBranchSupplierIds(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = UdxProductSerializerState::UdxEdxfPackingUnits(
                                    IterSerializer::new(
                                        self.value.udx_edxf_packing_units.as_ref(),
                                        Some("UDX.EDXF.PACKING_UNITS"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfPackingUnits(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    UdxProductSerializerState::UdxEdxfProductLogisticDetails(
                                        IterSerializer::new(
                                            self.value.udx_edxf_product_logistic_details.as_ref(),
                                            Some("UDX.EDXF.PRODUCT_LOGISTIC_DETAILS"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfProductLogisticDetails(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    UdxProductSerializerState::UdxEdxfReach(IterSerializer::new(
                                        self.value.udx_edxf_reach.as_ref(),
                                        Some("UDX.EDXF.REACH"),
                                        false,
                                    ))
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfReach(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = UdxProductSerializerState::UdxEdxfSurchargeList(
                                    IterSerializer::new(
                                        self.value.udx_edxf_surcharge_list.as_ref(),
                                        Some("UDX.EDXF.SURCHARGE_LIST"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    UdxProductSerializerState::UdxEdxfSurchargeList(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = UdxProductSerializerState::End__,
                        }
                    }
                    UdxProductSerializerState::End__ => {
                        *self.state = UdxProductSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    UdxProductSerializerState::Done__ => return Ok(None),
                    UdxProductSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for UdxProductSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = UdxProductSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct ProductReferenceElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::ProductReferenceElementType,
        pub(super) state: Box<ProductReferenceElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum ProductReferenceElementTypeSerializerState<'ser> {
        Init__,
        ProdIdTo(<String as WithSerializer>::Serializer<'ser>),
        CatalogId(IterSerializer<'ser, Option<&'ser String>, String>),
        CatalogVersion(IterSerializer<'ser, Option<&'ser String>, String>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> ProductReferenceElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    ProductReferenceElementTypeSerializerState::Init__ => {
                        *self.state = ProductReferenceElementTypeSerializerState::ProdIdTo(
                            WithSerializer::serializer(
                                &self.value.prod_id_to,
                                Some("PROD_ID_TO"),
                                false,
                            )?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib(&mut bytes, "type", &self.value.type_)?;
                        helper.write_attrib_opt(&mut bytes, "quantity", &self.value.quantity)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    ProductReferenceElementTypeSerializerState::ProdIdTo(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = ProductReferenceElementTypeSerializerState::CatalogId(
                                    IterSerializer::new(
                                        self.value.catalog_id.as_ref(),
                                        Some("CATALOG_ID"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    ProductReferenceElementTypeSerializerState::CatalogId(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductReferenceElementTypeSerializerState::CatalogVersion(
                                        IterSerializer::new(
                                            self.value.catalog_version.as_ref(),
                                            Some("CATALOG_VERSION"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    ProductReferenceElementTypeSerializerState::CatalogVersion(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = ProductReferenceElementTypeSerializerState::End__,
                        }
                    }
                    ProductReferenceElementTypeSerializerState::End__ => {
                        *self.state = ProductReferenceElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    ProductReferenceElementTypeSerializerState::Done__ => return Ok(None),
                    ProductReferenceElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for ProductReferenceElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = ProductReferenceElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct ProductLogisticDetailsElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::ProductLogisticDetailsElementType,
        pub(super) state: Box<ProductLogisticDetailsElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum ProductLogisticDetailsElementTypeSerializerState<'ser> {
        Init__,
        CustomsTariffNumber(
            IterSerializer<
                'ser,
                &'ser [super::CustomsTariffNumberElementType],
                super::CustomsTariffNumberElementType,
            >,
        ),
        StatisticsFactor(IterSerializer<'ser, Option<&'ser f64>, f64>),
        CountryOfOrigin(IterSerializer<'ser, &'ser [String], String>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> ProductLogisticDetailsElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    ProductLogisticDetailsElementTypeSerializerState::Init__ => {
                        *self.state =
                            ProductLogisticDetailsElementTypeSerializerState::CustomsTariffNumber(
                                IterSerializer::new(
                                    &self.value.customs_tariff_number[..],
                                    Some("CUSTOMS_TARIFF_NUMBER"),
                                    false,
                                ),
                            );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    ProductLogisticDetailsElementTypeSerializerState::CustomsTariffNumber(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state =
                                ProductLogisticDetailsElementTypeSerializerState::StatisticsFactor(
                                    IterSerializer::new(
                                        self.value.statistics_factor.as_ref(),
                                        Some("STATISTICS_FACTOR"),
                                        false,
                                    ),
                                ),
                        }
                    }
                    ProductLogisticDetailsElementTypeSerializerState::StatisticsFactor(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state =
                                ProductLogisticDetailsElementTypeSerializerState::CountryOfOrigin(
                                    IterSerializer::new(
                                        &self.value.country_of_origin[..],
                                        Some("COUNTRY_OF_ORIGIN"),
                                        false,
                                    ),
                                ),
                        }
                    }
                    ProductLogisticDetailsElementTypeSerializerState::CountryOfOrigin(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductLogisticDetailsElementTypeSerializerState::End__
                            }
                        }
                    }
                    ProductLogisticDetailsElementTypeSerializerState::End__ => {
                        *self.state = ProductLogisticDetailsElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    ProductLogisticDetailsElementTypeSerializerState::Done__ => return Ok(None),
                    ProductLogisticDetailsElementTypeSerializerState::Phantom__(_) => {
                        unreachable!()
                    }
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for ProductLogisticDetailsElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = ProductLogisticDetailsElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct MimeElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::MimeElementType,
        pub(super) state: Box<MimeElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum MimeElementTypeSerializerState<'ser> {
        Init__,
        MimeType(<String as WithSerializer>::Serializer<'ser>),
        MimeSource(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        MimeDescr(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        MimeAlt(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        MimePurpose(<super::MimePurposeElementType as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> MimeElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    MimeElementTypeSerializerState::Init__ => {
                        *self.state =
                            MimeElementTypeSerializerState::MimeType(WithSerializer::serializer(
                                &self.value.mime_type,
                                Some("MIME_TYPE"),
                                false,
                            )?);
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    MimeElementTypeSerializerState::MimeType(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    MimeElementTypeSerializerState::MimeSource(IterSerializer::new(
                                        &self.value.mime_source[..],
                                        Some("MIME_SOURCE"),
                                        false,
                                    ))
                            }
                        }
                    }
                    MimeElementTypeSerializerState::MimeSource(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    MimeElementTypeSerializerState::MimeDescr(IterSerializer::new(
                                        &self.value.mime_descr[..],
                                        Some("MIME_DESCR"),
                                        false,
                                    ))
                            }
                        }
                    }
                    MimeElementTypeSerializerState::MimeDescr(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    MimeElementTypeSerializerState::MimeAlt(IterSerializer::new(
                                        &self.value.mime_alt[..],
                                        Some("MIME_ALT"),
                                        false,
                                    ))
                            }
                        }
                    }
                    MimeElementTypeSerializerState::MimeAlt(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = MimeElementTypeSerializerState::MimePurpose(
                                    WithSerializer::serializer(
                                        &self.value.mime_purpose,
                                        Some("MIME_PURPOSE"),
                                        false,
                                    )?,
                                )
                            }
                        }
                    }
                    MimeElementTypeSerializerState::MimePurpose(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = MimeElementTypeSerializerState::End__,
                        }
                    }
                    MimeElementTypeSerializerState::End__ => {
                        *self.state = MimeElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    MimeElementTypeSerializerState::Done__ => return Ok(None),
                    MimeElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for MimeElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = MimeElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct InternationalPidElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::InternationalPidElementType,
        pub(super) state: Box<InternationalPidElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum InternationalPidElementTypeSerializerState<'ser> {
        Init__,
        Content__(<String as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> InternationalPidElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    InternationalPidElementTypeSerializerState::Init__ => {
                        *self.state = InternationalPidElementTypeSerializerState::Content__(
                            WithSerializer::serializer(&self.value.content, None, false)?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib_opt(&mut bytes, "type", &self.value.type_)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    InternationalPidElementTypeSerializerState::Content__(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = InternationalPidElementTypeSerializerState::End__,
                        }
                    }
                    InternationalPidElementTypeSerializerState::End__ => {
                        *self.state = InternationalPidElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    InternationalPidElementTypeSerializerState::Done__ => return Ok(None),
                    InternationalPidElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for InternationalPidElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = InternationalPidElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct BuyerPidElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::BuyerPidElementType,
        pub(super) state: Box<BuyerPidElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum BuyerPidElementTypeSerializerState<'ser> {
        Init__,
        Content__(<String as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> BuyerPidElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    BuyerPidElementTypeSerializerState::Init__ => {
                        *self.state = BuyerPidElementTypeSerializerState::Content__(
                            WithSerializer::serializer(&self.value.content, None, false)?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib_opt(&mut bytes, "type", &self.value.type_)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    BuyerPidElementTypeSerializerState::Content__(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = BuyerPidElementTypeSerializerState::End__,
                        }
                    }
                    BuyerPidElementTypeSerializerState::End__ => {
                        *self.state = BuyerPidElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    BuyerPidElementTypeSerializerState::Done__ => return Ok(None),
                    BuyerPidElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for BuyerPidElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = BuyerPidElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct SpecialTreatmentClassElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::SpecialTreatmentClassElementType,
        pub(super) state: Box<SpecialTreatmentClassElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum SpecialTreatmentClassElementTypeSerializerState<'ser> {
        Init__,
        Content__(<String as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> SpecialTreatmentClassElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    SpecialTreatmentClassElementTypeSerializerState::Init__ => {
                        *self.state = SpecialTreatmentClassElementTypeSerializerState::Content__(
                            WithSerializer::serializer(&self.value.content, None, false)?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib(&mut bytes, "type", &self.value.type_)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    SpecialTreatmentClassElementTypeSerializerState::Content__(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = SpecialTreatmentClassElementTypeSerializerState::End__
                            }
                        }
                    }
                    SpecialTreatmentClassElementTypeSerializerState::End__ => {
                        *self.state = SpecialTreatmentClassElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    SpecialTreatmentClassElementTypeSerializerState::Done__ => return Ok(None),
                    SpecialTreatmentClassElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for SpecialTreatmentClassElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = SpecialTreatmentClassElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct RemarksElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::RemarksElementType,
        pub(super) state: Box<RemarksElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum RemarksElementTypeSerializerState<'ser> {
        Init__,
        Content__(<String as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> RemarksElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    RemarksElementTypeSerializerState::Init__ => {
                        *self.state = RemarksElementTypeSerializerState::Content__(
                            WithSerializer::serializer(&self.value.content, None, false)?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib_opt(&mut bytes, "lang", &self.value.lang)?;
                        helper.write_attrib_opt(&mut bytes, "type", &self.value.type_)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    RemarksElementTypeSerializerState::Content__(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = RemarksElementTypeSerializerState::End__,
                        }
                    }
                    RemarksElementTypeSerializerState::End__ => {
                        *self.state = RemarksElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    RemarksElementTypeSerializerState::Done__ => return Ok(None),
                    RemarksElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for RemarksElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = RemarksElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct ProductStatusElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::ProductStatusElementType,
        pub(super) state: Box<ProductStatusElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum ProductStatusElementTypeSerializerState<'ser> {
        Init__,
        Content__(<String as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> ProductStatusElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    ProductStatusElementTypeSerializerState::Init__ => {
                        *self.state = ProductStatusElementTypeSerializerState::Content__(
                            WithSerializer::serializer(&self.value.content, None, false)?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib_opt(&mut bytes, "lang", &self.value.lang)?;
                        helper.write_attrib(&mut bytes, "type", &self.value.type_)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    ProductStatusElementTypeSerializerState::Content__(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = ProductStatusElementTypeSerializerState::End__,
                        }
                    }
                    ProductStatusElementTypeSerializerState::End__ => {
                        *self.state = ProductStatusElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    ProductStatusElementTypeSerializerState::Done__ => return Ok(None),
                    ProductStatusElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for ProductStatusElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = ProductStatusElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct TypeClassificationGroupIdSerializer<'ser> {
        pub(super) value: &'ser super::TypeClassificationGroupId,
        pub(super) state: Box<TypeClassificationGroupIdSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum TypeClassificationGroupIdSerializerState<'ser> {
        Init__,
        Content__(<String as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> TypeClassificationGroupIdSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    TypeClassificationGroupIdSerializerState::Init__ => {
                        *self.state = TypeClassificationGroupIdSerializerState::Content__(
                            WithSerializer::serializer(&self.value.content, None, false)?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib_opt(&mut bytes, "type", &self.value.type_)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    TypeClassificationGroupIdSerializerState::Content__(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = TypeClassificationGroupIdSerializerState::End__,
                        }
                    }
                    TypeClassificationGroupIdSerializerState::End__ => {
                        *self.state = TypeClassificationGroupIdSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    TypeClassificationGroupIdSerializerState::Done__ => return Ok(None),
                    TypeClassificationGroupIdSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for TypeClassificationGroupIdSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = TypeClassificationGroupIdSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct FeatureElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::FeatureElementType,
        pub(super) state: Box<FeatureElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum FeatureElementTypeSerializerState<'ser> {
        Init__,
        Fname(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        Fvalue(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        Funit(IterSerializer<'ser, Option<&'ser String>, String>),
        FvalueDetails(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> FeatureElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    FeatureElementTypeSerializerState::Init__ => {
                        *self.state = FeatureElementTypeSerializerState::Fname(
                            IterSerializer::new(&self.value.fname[..], Some("FNAME"), false),
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    FeatureElementTypeSerializerState::Fname(x) => match x
                        .next(helper)
                        .transpose()?
                    {
                        Some(event) => return Ok(Some(event)),
                        None => {
                            *self.state = FeatureElementTypeSerializerState::Fvalue(
                                IterSerializer::new(&self.value.fvalue[..], Some("FVALUE"), false),
                            )
                        }
                    },
                    FeatureElementTypeSerializerState::Fvalue(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    FeatureElementTypeSerializerState::Funit(IterSerializer::new(
                                        self.value.funit.as_ref(),
                                        Some("FUNIT"),
                                        false,
                                    ))
                            }
                        }
                    }
                    FeatureElementTypeSerializerState::Funit(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = FeatureElementTypeSerializerState::FvalueDetails(
                                    IterSerializer::new(
                                        &self.value.fvalue_details[..],
                                        Some("FVALUE_DETAILS"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    FeatureElementTypeSerializerState::FvalueDetails(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = FeatureElementTypeSerializerState::End__,
                        }
                    }
                    FeatureElementTypeSerializerState::End__ => {
                        *self.state = FeatureElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    FeatureElementTypeSerializerState::Done__ => return Ok(None),
                    FeatureElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for FeatureElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = FeatureElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct ProductPriceDetailsDatetimeElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::ProductPriceDetailsDatetimeElementType,
        pub(super) state: Box<ProductPriceDetailsDatetimeElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum ProductPriceDetailsDatetimeElementTypeSerializerState<'ser> {
        Init__,
        Date(<String as WithSerializer>::Serializer<'ser>),
        Time(IterSerializer<'ser, Option<&'ser String>, String>),
        Timezone(IterSerializer<'ser, Option<&'ser String>, String>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> ProductPriceDetailsDatetimeElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    ProductPriceDetailsDatetimeElementTypeSerializerState::Init__ => {
                        *self.state = ProductPriceDetailsDatetimeElementTypeSerializerState::Date(
                            WithSerializer::serializer(&self.value.date, Some("DATE"), false)?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib(&mut bytes, "type", &self.value.type_)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    ProductPriceDetailsDatetimeElementTypeSerializerState::Date(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductPriceDetailsDatetimeElementTypeSerializerState::Time(
                                        IterSerializer::new(
                                            self.value.time.as_ref(),
                                            Some("TIME"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    ProductPriceDetailsDatetimeElementTypeSerializerState::Time(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductPriceDetailsDatetimeElementTypeSerializerState::Timezone(
                                        IterSerializer::new(
                                            self.value.timezone.as_ref(),
                                            Some("TIMEZONE"),
                                            false,
                                        ),
                                    )
                            }
                        }
                    }
                    ProductPriceDetailsDatetimeElementTypeSerializerState::Timezone(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    ProductPriceDetailsDatetimeElementTypeSerializerState::End__
                            }
                        }
                    }
                    ProductPriceDetailsDatetimeElementTypeSerializerState::End__ => {
                        *self.state = ProductPriceDetailsDatetimeElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    ProductPriceDetailsDatetimeElementTypeSerializerState::Done__ => {
                        return Ok(None)
                    }
                    ProductPriceDetailsDatetimeElementTypeSerializerState::Phantom__(_) => {
                        unreachable!()
                    }
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for ProductPriceDetailsDatetimeElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = ProductPriceDetailsDatetimeElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct ProductPriceElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::ProductPriceElementType,
        pub(super) state: Box<ProductPriceElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum ProductPriceElementTypeSerializerState<'ser> {
        Init__,
        PriceAmount(<f64 as WithSerializer>::Serializer<'ser>),
        PriceCurrency(IterSerializer<'ser, Option<&'ser super::DtCurrencies>, super::DtCurrencies>),
        Tax(IterSerializer<'ser, Option<&'ser f64>, f64>),
        PriceFactor(IterSerializer<'ser, Option<&'ser f64>, f64>),
        LowerBound(IterSerializer<'ser, Option<&'ser f64>, f64>),
        Territory(IterSerializer<'ser, &'ser [String], String>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> ProductPriceElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    ProductPriceElementTypeSerializerState::Init__ => {
                        *self.state = ProductPriceElementTypeSerializerState::PriceAmount(
                            WithSerializer::serializer(
                                &self.value.price_amount,
                                Some("PRICE_AMOUNT"),
                                false,
                            )?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib(&mut bytes, "price_type", &self.value.price_type)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    ProductPriceElementTypeSerializerState::PriceAmount(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = ProductPriceElementTypeSerializerState::PriceCurrency(
                                    IterSerializer::new(
                                        self.value.price_currency.as_ref(),
                                        Some("PRICE_CURRENCY"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    ProductPriceElementTypeSerializerState::PriceCurrency(x) => match x
                        .next(helper)
                        .transpose()?
                    {
                        Some(event) => return Ok(Some(event)),
                        None => {
                            *self.state = ProductPriceElementTypeSerializerState::Tax(
                                IterSerializer::new(self.value.tax.as_ref(), Some("TAX"), false),
                            )
                        }
                    },
                    ProductPriceElementTypeSerializerState::Tax(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = ProductPriceElementTypeSerializerState::PriceFactor(
                                    IterSerializer::new(
                                        self.value.price_factor.as_ref(),
                                        Some("PRICE_FACTOR"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    ProductPriceElementTypeSerializerState::PriceFactor(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = ProductPriceElementTypeSerializerState::LowerBound(
                                    IterSerializer::new(
                                        self.value.lower_bound.as_ref(),
                                        Some("LOWER_BOUND"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    ProductPriceElementTypeSerializerState::LowerBound(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state = ProductPriceElementTypeSerializerState::Territory(
                                    IterSerializer::new(
                                        &self.value.territory[..],
                                        Some("TERRITORY"),
                                        false,
                                    ),
                                )
                            }
                        }
                    }
                    ProductPriceElementTypeSerializerState::Territory(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = ProductPriceElementTypeSerializerState::End__,
                        }
                    }
                    ProductPriceElementTypeSerializerState::End__ => {
                        *self.state = ProductPriceElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    ProductPriceElementTypeSerializerState::Done__ => return Ok(None),
                    ProductPriceElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for ProductPriceElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = ProductPriceElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfDiscountGroupElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::UdxEdxfDiscountGroupElementType,
        pub(super) state: Box<UdxEdxfDiscountGroupElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum UdxEdxfDiscountGroupElementTypeSerializerState<'ser> {
        Init__,
        Content__(
            IterSerializer<
                'ser,
                &'ser [super::UdxEdxfDiscountGroupElementTypeContent],
                super::UdxEdxfDiscountGroupElementTypeContent,
            >,
        ),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> UdxEdxfDiscountGroupElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    UdxEdxfDiscountGroupElementTypeSerializerState::Init__ => {
                        *self.state = UdxEdxfDiscountGroupElementTypeSerializerState::Content__(
                            IterSerializer::new(&self.value.content[..], None, false),
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    UdxEdxfDiscountGroupElementTypeSerializerState::Content__(x) => match x
                        .next(helper)
                        .transpose()?
                    {
                        Some(event) => return Ok(Some(event)),
                        None => *self.state = UdxEdxfDiscountGroupElementTypeSerializerState::End__,
                    },
                    UdxEdxfDiscountGroupElementTypeSerializerState::End__ => {
                        *self.state = UdxEdxfDiscountGroupElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    UdxEdxfDiscountGroupElementTypeSerializerState::Done__ => return Ok(None),
                    UdxEdxfDiscountGroupElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for UdxEdxfDiscountGroupElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = UdxEdxfDiscountGroupElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfDiscountGroupElementTypeContentSerializer<'ser> {
        pub(super) value: &'ser super::UdxEdxfDiscountGroupElementTypeContent,
        pub(super) state: Box<UdxEdxfDiscountGroupElementTypeContentSerializerState<'ser>>,
    }
    #[derive(Debug)]
    pub(super) enum UdxEdxfDiscountGroupElementTypeContentSerializerState<'ser> {
        Init__,
        UdxEdxfDiscountGroupManufacturer(<String as WithSerializer>::Serializer<'ser>),
        UdxEdxfDiscountGroupSupplier(<String as WithSerializer>::Serializer<'ser>),
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> UdxEdxfDiscountGroupElementTypeContentSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match & mut * self . state { UdxEdxfDiscountGroupElementTypeContentSerializerState :: Init__ => { match self . value { super :: UdxEdxfDiscountGroupElementTypeContent :: UdxEdxfDiscountGroupManufacturer (x) => * self . state = UdxEdxfDiscountGroupElementTypeContentSerializerState :: UdxEdxfDiscountGroupManufacturer (WithSerializer :: serializer (x , Some ("UDX.EDXF.DISCOUNT_GROUP_MANUFACTURER") , false) ?) , super :: UdxEdxfDiscountGroupElementTypeContent :: UdxEdxfDiscountGroupSupplier (x) => * self . state = UdxEdxfDiscountGroupElementTypeContentSerializerState :: UdxEdxfDiscountGroupSupplier (WithSerializer :: serializer (x , Some ("UDX.EDXF.DISCOUNT_GROUP_SUPPLIER") , false) ?) , } } UdxEdxfDiscountGroupElementTypeContentSerializerState :: UdxEdxfDiscountGroupManufacturer (x) => { match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfDiscountGroupElementTypeContentSerializerState :: Done__ , } } UdxEdxfDiscountGroupElementTypeContentSerializerState :: UdxEdxfDiscountGroupSupplier (x) => { match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfDiscountGroupElementTypeContentSerializerState :: Done__ , } } UdxEdxfDiscountGroupElementTypeContentSerializerState :: Done__ => return Ok (None) , UdxEdxfDiscountGroupElementTypeContentSerializerState :: Phantom__ (_) => unreachable ! () , }
            }
        }
    }
    impl<'ser> Serializer<'ser> for UdxEdxfDiscountGroupElementTypeContentSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = UdxEdxfDiscountGroupElementTypeContentSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfDeclarationElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::UdxEdxfDeclarationElementType,
        pub(super) state: Box<UdxEdxfDeclarationElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum UdxEdxfDeclarationElementTypeSerializerState<'ser> {
        Init__,
        Content__(<String as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> UdxEdxfDeclarationElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    UdxEdxfDeclarationElementTypeSerializerState::Init__ => {
                        *self.state = UdxEdxfDeclarationElementTypeSerializerState::Content__(
                            WithSerializer::serializer(&self.value.content, None, false)?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        helper.write_attrib(&mut bytes, "type", &self.value.type_)?;
                        helper.write_attrib_opt(&mut bytes, "date", &self.value.date)?;
                        return Ok(Some(Event::Start(bytes)));
                    }
                    UdxEdxfDeclarationElementTypeSerializerState::Content__(x) => match x
                        .next(helper)
                        .transpose()?
                    {
                        Some(event) => return Ok(Some(event)),
                        None => *self.state = UdxEdxfDeclarationElementTypeSerializerState::End__,
                    },
                    UdxEdxfDeclarationElementTypeSerializerState::End__ => {
                        *self.state = UdxEdxfDeclarationElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    UdxEdxfDeclarationElementTypeSerializerState::Done__ => return Ok(None),
                    UdxEdxfDeclarationElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for UdxEdxfDeclarationElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = UdxEdxfDeclarationElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfAdditionalFactorsElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::UdxEdxfAdditionalFactorsElementType,
        pub(super) state: Box<UdxEdxfAdditionalFactorsElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum UdxEdxfAdditionalFactorsElementTypeSerializerState<'ser> {
        Init__,
        UdxEdxfAdditionalPriceFactor(<f64 as WithSerializer>::Serializer<'ser>),
        UdxEdxfAdditionalFactorInfo(<super::DtMlstring as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> UdxEdxfAdditionalFactorsElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match & mut * self . state { UdxEdxfAdditionalFactorsElementTypeSerializerState :: Init__ => { * self . state = UdxEdxfAdditionalFactorsElementTypeSerializerState :: UdxEdxfAdditionalPriceFactor (WithSerializer :: serializer (& self . value . udx_edxf_additional_price_factor , Some ("UDX.EDXF.ADDITIONAL_PRICE_FACTOR") , false) ?) ; let mut bytes = BytesStart :: new (self . name) ; helper . begin_ns_scope () ; helper . write_xmlns (& mut bytes , None , & super :: NS_UNNAMED_5) ; return Ok (Some (Event :: Start (bytes))) } UdxEdxfAdditionalFactorsElementTypeSerializerState :: UdxEdxfAdditionalPriceFactor (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfAdditionalFactorsElementTypeSerializerState :: UdxEdxfAdditionalFactorInfo (WithSerializer :: serializer (& self . value . udx_edxf_additional_factor_info , Some ("UDX.EDXF.ADDITIONAL_FACTOR_INFO") , false) ?) , } UdxEdxfAdditionalFactorsElementTypeSerializerState :: UdxEdxfAdditionalFactorInfo (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfAdditionalFactorsElementTypeSerializerState :: End__ , } UdxEdxfAdditionalFactorsElementTypeSerializerState :: End__ => { * self . state = UdxEdxfAdditionalFactorsElementTypeSerializerState :: Done__ ; helper . end_ns_scope () ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } UdxEdxfAdditionalFactorsElementTypeSerializerState :: Done__ => return Ok (None) , UdxEdxfAdditionalFactorsElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
            }
        }
    }
    impl<'ser> Serializer<'ser> for UdxEdxfAdditionalFactorsElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = UdxEdxfAdditionalFactorsElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfCountryBranchNumbersElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::UdxEdxfCountryBranchNumbersElementType,
        pub(super) state: Box<UdxEdxfCountryBranchNumbersElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum UdxEdxfCountryBranchNumbersElementTypeSerializerState<'ser> {
        Init__,
        UdxEdxfCountryBranchNumber(
            IterSerializer<
                'ser,
                &'ser [super::UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementType],
                super::UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementType,
            >,
        ),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> UdxEdxfCountryBranchNumbersElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match & mut * self . state { UdxEdxfCountryBranchNumbersElementTypeSerializerState :: Init__ => { * self . state = UdxEdxfCountryBranchNumbersElementTypeSerializerState :: UdxEdxfCountryBranchNumber (IterSerializer :: new (& self . value . udx_edxf_country_branch_number [..] , Some ("UDX.EDXF.COUNTRY_BRANCH_NUMBER") , false)) ; let mut bytes = BytesStart :: new (self . name) ; helper . begin_ns_scope () ; helper . write_xmlns (& mut bytes , None , & super :: NS_UNNAMED_5) ; return Ok (Some (Event :: Start (bytes))) } UdxEdxfCountryBranchNumbersElementTypeSerializerState :: UdxEdxfCountryBranchNumber (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfCountryBranchNumbersElementTypeSerializerState :: End__ , } UdxEdxfCountryBranchNumbersElementTypeSerializerState :: End__ => { * self . state = UdxEdxfCountryBranchNumbersElementTypeSerializerState :: Done__ ; helper . end_ns_scope () ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } UdxEdxfCountryBranchNumbersElementTypeSerializerState :: Done__ => return Ok (None) , UdxEdxfCountryBranchNumbersElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
            }
        }
    }
    impl<'ser> Serializer<'ser> for UdxEdxfCountryBranchNumbersElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = UdxEdxfCountryBranchNumbersElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfCountryBranchSupplierIdsElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::UdxEdxfCountryBranchSupplierIdsElementType,
        pub(super) state: Box<UdxEdxfCountryBranchSupplierIdsElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum UdxEdxfCountryBranchSupplierIdsElementTypeSerializerState<'ser> {
        Init__ , UdxEdxfCountryBranchSupplierId (IterSerializer < 'ser , & 'ser [super :: UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementType] , super :: UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementType >) , End__ , Done__ , Phantom__ (& 'ser ()) , }
    impl<'ser> UdxEdxfCountryBranchSupplierIdsElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match & mut * self . state { UdxEdxfCountryBranchSupplierIdsElementTypeSerializerState :: Init__ => { * self . state = UdxEdxfCountryBranchSupplierIdsElementTypeSerializerState :: UdxEdxfCountryBranchSupplierId (IterSerializer :: new (& self . value . udx_edxf_country_branch_supplier_id [..] , Some ("UDX.EDXF.COUNTRY_BRANCH_SUPPLIER_ID") , false)) ; let mut bytes = BytesStart :: new (self . name) ; helper . begin_ns_scope () ; helper . write_xmlns (& mut bytes , None , & super :: NS_UNNAMED_5) ; return Ok (Some (Event :: Start (bytes))) } UdxEdxfCountryBranchSupplierIdsElementTypeSerializerState :: UdxEdxfCountryBranchSupplierId (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfCountryBranchSupplierIdsElementTypeSerializerState :: End__ , } UdxEdxfCountryBranchSupplierIdsElementTypeSerializerState :: End__ => { * self . state = UdxEdxfCountryBranchSupplierIdsElementTypeSerializerState :: Done__ ; helper . end_ns_scope () ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } UdxEdxfCountryBranchSupplierIdsElementTypeSerializerState :: Done__ => return Ok (None) , UdxEdxfCountryBranchSupplierIdsElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
            }
        }
    }
    impl<'ser> Serializer<'ser> for UdxEdxfCountryBranchSupplierIdsElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = UdxEdxfCountryBranchSupplierIdsElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfPackingUnitsElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::UdxEdxfPackingUnitsElementType,
        pub(super) state: Box<UdxEdxfPackingUnitsElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum UdxEdxfPackingUnitsElementTypeSerializerState<'ser> {
        Init__,
        UdxEdxfPackingUnit(
            IterSerializer<
                'ser,
                &'ser [super::UdxEdxfPackingUnitElementType],
                super::UdxEdxfPackingUnitElementType,
            >,
        ),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> UdxEdxfPackingUnitsElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    UdxEdxfPackingUnitsElementTypeSerializerState::Init__ => {
                        *self.state =
                            UdxEdxfPackingUnitsElementTypeSerializerState::UdxEdxfPackingUnit(
                                IterSerializer::new(
                                    &self.value.udx_edxf_packing_unit[..],
                                    Some("UDX.EDXF.PACKING_UNIT"),
                                    false,
                                ),
                            );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    UdxEdxfPackingUnitsElementTypeSerializerState::UdxEdxfPackingUnit(x) => match x
                        .next(helper)
                        .transpose()?
                    {
                        Some(event) => return Ok(Some(event)),
                        None => *self.state = UdxEdxfPackingUnitsElementTypeSerializerState::End__,
                    },
                    UdxEdxfPackingUnitsElementTypeSerializerState::End__ => {
                        *self.state = UdxEdxfPackingUnitsElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    UdxEdxfPackingUnitsElementTypeSerializerState::Done__ => return Ok(None),
                    UdxEdxfPackingUnitsElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for UdxEdxfPackingUnitsElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = UdxEdxfPackingUnitsElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfProductLogisticDetailsElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::UdxEdxfProductLogisticDetailsElementType,
        pub(super) state: Box<UdxEdxfProductLogisticDetailsElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum UdxEdxfProductLogisticDetailsElementTypeSerializerState<'ser> {
        Init__,
        UdxEdxfNetweight(IterSerializer<'ser, Option<&'ser f64>, f64>),
        UdxEdxfRegionOfOrigin(IterSerializer<'ser, Option<&'ser String>, String>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> UdxEdxfProductLogisticDetailsElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match & mut * self . state { UdxEdxfProductLogisticDetailsElementTypeSerializerState :: Init__ => { * self . state = UdxEdxfProductLogisticDetailsElementTypeSerializerState :: UdxEdxfNetweight (IterSerializer :: new (self . value . udx_edxf_netweight . as_ref () , Some ("UDX.EDXF.NETWEIGHT") , false)) ; let mut bytes = BytesStart :: new (self . name) ; helper . begin_ns_scope () ; helper . write_xmlns (& mut bytes , None , & super :: NS_UNNAMED_5) ; return Ok (Some (Event :: Start (bytes))) } UdxEdxfProductLogisticDetailsElementTypeSerializerState :: UdxEdxfNetweight (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfProductLogisticDetailsElementTypeSerializerState :: UdxEdxfRegionOfOrigin (IterSerializer :: new (self . value . udx_edxf_region_of_origin . as_ref () , Some ("UDX.EDXF.REGION_OF_ORIGIN") , false)) , } UdxEdxfProductLogisticDetailsElementTypeSerializerState :: UdxEdxfRegionOfOrigin (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfProductLogisticDetailsElementTypeSerializerState :: End__ , } UdxEdxfProductLogisticDetailsElementTypeSerializerState :: End__ => { * self . state = UdxEdxfProductLogisticDetailsElementTypeSerializerState :: Done__ ; helper . end_ns_scope () ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } UdxEdxfProductLogisticDetailsElementTypeSerializerState :: Done__ => return Ok (None) , UdxEdxfProductLogisticDetailsElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
            }
        }
    }
    impl<'ser> Serializer<'ser> for UdxEdxfProductLogisticDetailsElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = UdxEdxfProductLogisticDetailsElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfReachElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::UdxEdxfReachElementType,
        pub(super) state: Box<UdxEdxfReachElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum UdxEdxfReachElementTypeSerializerState<'ser> {
        Init__,
        UdxEdxfReachListdate(IterSerializer<'ser, Option<&'ser String>, String>),
        UdxEdxfReachInfo(<String as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> UdxEdxfReachElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    UdxEdxfReachElementTypeSerializerState::Init__ => {
                        *self.state = UdxEdxfReachElementTypeSerializerState::UdxEdxfReachListdate(
                            IterSerializer::new(
                                self.value.udx_edxf_reach_listdate.as_ref(),
                                Some("UDX.EDXF.REACH.LISTDATE"),
                                false,
                            ),
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    UdxEdxfReachElementTypeSerializerState::UdxEdxfReachListdate(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => {
                                *self.state =
                                    UdxEdxfReachElementTypeSerializerState::UdxEdxfReachInfo(
                                        WithSerializer::serializer(
                                            &self.value.udx_edxf_reach_info,
                                            Some("UDX.EDXF.REACH.INFO"),
                                            false,
                                        )?,
                                    )
                            }
                        }
                    }
                    UdxEdxfReachElementTypeSerializerState::UdxEdxfReachInfo(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = UdxEdxfReachElementTypeSerializerState::End__,
                        }
                    }
                    UdxEdxfReachElementTypeSerializerState::End__ => {
                        *self.state = UdxEdxfReachElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    UdxEdxfReachElementTypeSerializerState::Done__ => return Ok(None),
                    UdxEdxfReachElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for UdxEdxfReachElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = UdxEdxfReachElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfSurchargeListElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::UdxEdxfSurchargeListElementType,
        pub(super) state: Box<UdxEdxfSurchargeListElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum UdxEdxfSurchargeListElementTypeSerializerState<'ser> {
        Init__,
        UdxEdxfSurcharge(
            IterSerializer<
                'ser,
                &'ser [super::UdxEdxfSurchargeElementType],
                super::UdxEdxfSurchargeElementType,
            >,
        ),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> UdxEdxfSurchargeListElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    UdxEdxfSurchargeListElementTypeSerializerState::Init__ => {
                        *self.state =
                            UdxEdxfSurchargeListElementTypeSerializerState::UdxEdxfSurcharge(
                                IterSerializer::new(
                                    &self.value.udx_edxf_surcharge[..],
                                    Some("UDX.EDXF.SURCHARGE"),
                                    false,
                                ),
                            );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    UdxEdxfSurchargeListElementTypeSerializerState::UdxEdxfSurcharge(x) => match x
                        .next(helper)
                        .transpose()?
                    {
                        Some(event) => return Ok(Some(event)),
                        None => *self.state = UdxEdxfSurchargeListElementTypeSerializerState::End__,
                    },
                    UdxEdxfSurchargeListElementTypeSerializerState::End__ => {
                        *self.state = UdxEdxfSurchargeListElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    UdxEdxfSurchargeListElementTypeSerializerState::Done__ => return Ok(None),
                    UdxEdxfSurchargeListElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for UdxEdxfSurchargeListElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = UdxEdxfSurchargeListElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct CustomsTariffNumberElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::CustomsTariffNumberElementType,
        pub(super) state: Box<CustomsTariffNumberElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum CustomsTariffNumberElementTypeSerializerState<'ser> {
        Init__,
        CustomsNumber(<String as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> CustomsTariffNumberElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    CustomsTariffNumberElementTypeSerializerState::Init__ => {
                        *self.state = CustomsTariffNumberElementTypeSerializerState::CustomsNumber(
                            WithSerializer::serializer(
                                &self.value.customs_number,
                                Some("CUSTOMS_NUMBER"),
                                false,
                            )?,
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    CustomsTariffNumberElementTypeSerializerState::CustomsNumber(x) => match x
                        .next(helper)
                        .transpose()?
                    {
                        Some(event) => return Ok(Some(event)),
                        None => *self.state = CustomsTariffNumberElementTypeSerializerState::End__,
                    },
                    CustomsTariffNumberElementTypeSerializerState::End__ => {
                        *self.state = CustomsTariffNumberElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    CustomsTariffNumberElementTypeSerializerState::Done__ => return Ok(None),
                    CustomsTariffNumberElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for CustomsTariffNumberElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = CustomsTariffNumberElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeSerializer<'ser> {
        pub(super) value:
            &'ser super::UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementType,
        pub(super) state: Box<
            UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeSerializerState<'ser>,
        >,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeSerializerState<
        'ser,
    > {
        Init__,
        Content__(<f64 as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match & mut * self . state { UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeSerializerState :: Init__ => { * self . state = UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeSerializerState :: Content__ (WithSerializer :: serializer (& self . value . content , None , false) ?) ; let mut bytes = BytesStart :: new (self . name) ; helper . begin_ns_scope () ; helper . write_xmlns (& mut bytes , None , & super :: NS_UNNAMED_5) ; helper . write_attrib (& mut bytes , "type" , & self . value . type_) ? ; helper . write_attrib (& mut bytes , "country" , & self . value . country) ? ; return Ok (Some (Event :: Start (bytes))) } UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeSerializerState :: Content__ (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeSerializerState :: End__ , } UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeSerializerState :: End__ => { * self . state = UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeSerializerState :: Done__ ; helper . end_ns_scope () ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeSerializerState :: Done__ => return Ok (None) , UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
            }
        }
    }
    impl<'ser> Serializer<'ser>
        for UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeSerializer<'ser>
    {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    * self . state = UdxEdxfCountryBranchNumbersUdxEdxfCountryBranchNumberElementTypeSerializerState :: Done__ ;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeSerializer<
        'ser,
    > {
        pub(super) value:
            &'ser super::UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementType,
        pub(super) state: Box<
            UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeSerializerState<
                'ser,
            >,
        >,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeSerializerState<
        'ser,
    > {
        Init__,
        Content__(<f64 as WithSerializer>::Serializer<'ser>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser>
        UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeSerializer<'ser>
    {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match & mut * self . state { UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeSerializerState :: Init__ => { * self . state = UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeSerializerState :: Content__ (WithSerializer :: serializer (& self . value . content , None , false) ?) ; let mut bytes = BytesStart :: new (self . name) ; helper . begin_ns_scope () ; helper . write_xmlns (& mut bytes , None , & super :: NS_UNNAMED_5) ; helper . write_attrib (& mut bytes , "type" , & self . value . type_) ? ; helper . write_attrib (& mut bytes , "country" , & self . value . country) ? ; return Ok (Some (Event :: Start (bytes))) } UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeSerializerState :: Content__ (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeSerializerState :: End__ , } UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeSerializerState :: End__ => { * self . state = UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeSerializerState :: Done__ ; helper . end_ns_scope () ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeSerializerState :: Done__ => return Ok (None) , UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
            }
        }
    }
    impl<'ser> Serializer<'ser>
        for UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeSerializer<'ser>
    {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    * self . state = UdxEdxfCountryBranchSupplierIdsUdxEdxfCountryBranchSupplierIdElementTypeSerializerState :: Done__ ;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfPackingUnitElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::UdxEdxfPackingUnitElementType,
        pub(super) state: Box<UdxEdxfPackingUnitElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum UdxEdxfPackingUnitElementTypeSerializerState<'ser> {
        Init__,
        UdxEdxfQuantityMin(<f32 as WithSerializer>::Serializer<'ser>),
        UdxEdxfQuantityMax(IterSerializer<'ser, Option<&'ser f32>, f32>),
        UdxEdxfPackingUnitCode(<super::DtPunit as WithSerializer>::Serializer<'ser>),
        UdxEdxfPackingUnitName(IterSerializer<'ser, &'ser [super::DtMlstring], super::DtMlstring>),
        UdxEdxfPackageBreak(IterSerializer<'ser, Option<&'ser String>, String>),
        UdxEdxfVolume(IterSerializer<'ser, Option<&'ser f64>, f64>),
        UdxEdxfWeight(IterSerializer<'ser, Option<&'ser f64>, f64>),
        UdxEdxfLength(IterSerializer<'ser, Option<&'ser f64>, f64>),
        UdxEdxfWidth(IterSerializer<'ser, Option<&'ser f64>, f64>),
        UdxEdxfDepth(IterSerializer<'ser, Option<&'ser f64>, f64>),
        UdxEdxfDiameter(IterSerializer<'ser, Option<&'ser f64>, f64>),
        UdxEdxfGtin(IterSerializer<'ser, Option<&'ser String>, String>),
        UdxEdxfGs1128(IterSerializer<'ser, Option<&'ser String>, String>),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> UdxEdxfPackingUnitElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match & mut * self . state { UdxEdxfPackingUnitElementTypeSerializerState :: Init__ => { * self . state = UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfQuantityMin (WithSerializer :: serializer (& self . value . udx_edxf_quantity_min , Some ("UDX.EDXF.QUANTITY_MIN") , false) ?) ; let mut bytes = BytesStart :: new (self . name) ; helper . begin_ns_scope () ; helper . write_xmlns (& mut bytes , None , & super :: NS_UNNAMED_5) ; return Ok (Some (Event :: Start (bytes))) } UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfQuantityMin (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfQuantityMax (IterSerializer :: new (self . value . udx_edxf_quantity_max . as_ref () , Some ("UDX.EDXF.QUANTITY_MAX") , false)) , } UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfQuantityMax (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfPackingUnitCode (WithSerializer :: serializer (& self . value . udx_edxf_packing_unit_code , Some ("UDX.EDXF.PACKING_UNIT_CODE") , false) ?) , } UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfPackingUnitCode (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfPackingUnitName (IterSerializer :: new (& self . value . udx_edxf_packing_unit_name [..] , Some ("UDX.EDXF.PACKING_UNIT_NAME") , false)) , } UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfPackingUnitName (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfPackageBreak (IterSerializer :: new (self . value . udx_edxf_package_break . as_ref () , Some ("UDX.EDXF.PACKAGE_BREAK") , false)) , } UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfPackageBreak (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfVolume (IterSerializer :: new (self . value . udx_edxf_volume . as_ref () , Some ("UDX.EDXF.VOLUME") , false)) , } UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfVolume (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfWeight (IterSerializer :: new (self . value . udx_edxf_weight . as_ref () , Some ("UDX.EDXF.WEIGHT") , false)) , } UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfWeight (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfLength (IterSerializer :: new (self . value . udx_edxf_length . as_ref () , Some ("UDX.EDXF.LENGTH") , false)) , } UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfLength (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfWidth (IterSerializer :: new (self . value . udx_edxf_width . as_ref () , Some ("UDX.EDXF.WIDTH") , false)) , } UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfWidth (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfDepth (IterSerializer :: new (self . value . udx_edxf_depth . as_ref () , Some ("UDX.EDXF.DEPTH") , false)) , } UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfDepth (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfDiameter (IterSerializer :: new (self . value . udx_edxf_diameter . as_ref () , Some ("UDX.EDXF.DIAMETER") , false)) , } UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfDiameter (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfGtin (IterSerializer :: new (self . value . udx_edxf_gtin . as_ref () , Some ("UDX.EDXF.GTIN") , false)) , } UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfGtin (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfGs1128 (IterSerializer :: new (self . value . udx_edxf_gs_1128 . as_ref () , Some ("UDX.EDXF.GS1_128") , false)) , } UdxEdxfPackingUnitElementTypeSerializerState :: UdxEdxfGs1128 (x) => match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfPackingUnitElementTypeSerializerState :: End__ , } UdxEdxfPackingUnitElementTypeSerializerState :: End__ => { * self . state = UdxEdxfPackingUnitElementTypeSerializerState :: Done__ ; helper . end_ns_scope () ; return Ok (Some (Event :: End (BytesEnd :: new (self . name)))) ; } UdxEdxfPackingUnitElementTypeSerializerState :: Done__ => return Ok (None) , UdxEdxfPackingUnitElementTypeSerializerState :: Phantom__ (_) => unreachable ! () , }
            }
        }
    }
    impl<'ser> Serializer<'ser> for UdxEdxfPackingUnitElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = UdxEdxfPackingUnitElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfSurchargeElementTypeSerializer<'ser> {
        pub(super) value: &'ser super::UdxEdxfSurchargeElementType,
        pub(super) state: Box<UdxEdxfSurchargeElementTypeSerializerState<'ser>>,
        pub(super) name: &'ser str,
        pub(super) is_root: bool,
    }
    #[derive(Debug)]
    pub(super) enum UdxEdxfSurchargeElementTypeSerializerState<'ser> {
        Init__,
        Content__(
            IterSerializer<
                'ser,
                &'ser [super::UdxEdxfSurchargeElementTypeContent],
                super::UdxEdxfSurchargeElementTypeContent,
            >,
        ),
        End__,
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> UdxEdxfSurchargeElementTypeSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match &mut *self.state {
                    UdxEdxfSurchargeElementTypeSerializerState::Init__ => {
                        *self.state = UdxEdxfSurchargeElementTypeSerializerState::Content__(
                            IterSerializer::new(&self.value.content[..], None, false),
                        );
                        let mut bytes = BytesStart::new(self.name);
                        helper.begin_ns_scope();
                        helper.write_xmlns(&mut bytes, None, &super::NS_UNNAMED_5);
                        return Ok(Some(Event::Start(bytes)));
                    }
                    UdxEdxfSurchargeElementTypeSerializerState::Content__(x) => {
                        match x.next(helper).transpose()? {
                            Some(event) => return Ok(Some(event)),
                            None => *self.state = UdxEdxfSurchargeElementTypeSerializerState::End__,
                        }
                    }
                    UdxEdxfSurchargeElementTypeSerializerState::End__ => {
                        *self.state = UdxEdxfSurchargeElementTypeSerializerState::Done__;
                        helper.end_ns_scope();
                        return Ok(Some(Event::End(BytesEnd::new(self.name))));
                    }
                    UdxEdxfSurchargeElementTypeSerializerState::Done__ => return Ok(None),
                    UdxEdxfSurchargeElementTypeSerializerState::Phantom__(_) => unreachable!(),
                }
            }
        }
    }
    impl<'ser> Serializer<'ser> for UdxEdxfSurchargeElementTypeSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = UdxEdxfSurchargeElementTypeSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
    #[derive(Debug)]
    pub struct UdxEdxfSurchargeElementTypeContentSerializer<'ser> {
        pub(super) value: &'ser super::UdxEdxfSurchargeElementTypeContent,
        pub(super) state: Box<UdxEdxfSurchargeElementTypeContentSerializerState<'ser>>,
    }
    #[derive(Debug)]
    pub(super) enum UdxEdxfSurchargeElementTypeContentSerializerState<'ser> {
        Init__,
        UdxEdxfSurchargeType(<String as WithSerializer>::Serializer<'ser>),
        UdxEdxfSurchargeManner(<String as WithSerializer>::Serializer<'ser>),
        UdxEdxfSurchargePercentage(<f64 as WithSerializer>::Serializer<'ser>),
        UdxEdxfSurchargePriceAmount(<f64 as WithSerializer>::Serializer<'ser>),
        UdxEdxfSurchargeCalculation(<f64 as WithSerializer>::Serializer<'ser>),
        UdxEdxfMaterialBasis(<f64 as WithSerializer>::Serializer<'ser>),
        UdxEdxfMaterialBasisWeight(<f64 as WithSerializer>::Serializer<'ser>),
        UdxEdxfMaterialBasisSurchargeThreshold(<f64 as WithSerializer>::Serializer<'ser>),
        UdxEdxfMaterialBasisSurchargeShutter(<i32 as WithSerializer>::Serializer<'ser>),
        UdxEdxfMaterialBasisSurchargeCredit(<i32 as WithSerializer>::Serializer<'ser>),
        UdxEdxfMaterialBasisSurchargeTable(<super::DtMlstring as WithSerializer>::Serializer<'ser>),
        Done__,
        Phantom__(&'ser ()),
    }
    impl<'ser> UdxEdxfSurchargeElementTypeContentSerializer<'ser> {
        fn next_event(
            &mut self,
            helper: &mut SerializeHelper,
        ) -> Result<Option<Event<'ser>>, Error> {
            loop {
                match & mut * self . state { UdxEdxfSurchargeElementTypeContentSerializerState :: Init__ => { match self . value { super :: UdxEdxfSurchargeElementTypeContent :: UdxEdxfSurchargeType (x) => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfSurchargeType (WithSerializer :: serializer (x , Some ("UDX.EDXF.SURCHARGE_TYPE") , false) ?) , super :: UdxEdxfSurchargeElementTypeContent :: UdxEdxfSurchargeManner (x) => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfSurchargeManner (WithSerializer :: serializer (x , Some ("UDX.EDXF.SURCHARGE_MANNER") , false) ?) , super :: UdxEdxfSurchargeElementTypeContent :: UdxEdxfSurchargePercentage (x) => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfSurchargePercentage (WithSerializer :: serializer (x , Some ("UDX.EDXF.SURCHARGE_PERCENTAGE") , false) ?) , super :: UdxEdxfSurchargeElementTypeContent :: UdxEdxfSurchargePriceAmount (x) => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfSurchargePriceAmount (WithSerializer :: serializer (x , Some ("UDX.EDXF.SURCHARGE_PRICE_AMOUNT") , false) ?) , super :: UdxEdxfSurchargeElementTypeContent :: UdxEdxfSurchargeCalculation (x) => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfSurchargeCalculation (WithSerializer :: serializer (x , Some ("UDX.EDXF.SURCHARGE_CALCULATION") , false) ?) , super :: UdxEdxfSurchargeElementTypeContent :: UdxEdxfMaterialBasis (x) => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfMaterialBasis (WithSerializer :: serializer (x , Some ("UDX.EDXF.MATERIAL_BASIS") , false) ?) , super :: UdxEdxfSurchargeElementTypeContent :: UdxEdxfMaterialBasisWeight (x) => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfMaterialBasisWeight (WithSerializer :: serializer (x , Some ("UDX.EDXF.MATERIAL_BASIS_WEIGHT") , false) ?) , super :: UdxEdxfSurchargeElementTypeContent :: UdxEdxfMaterialBasisSurchargeThreshold (x) => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfMaterialBasisSurchargeThreshold (WithSerializer :: serializer (x , Some ("UDX.EDXF.MATERIAL_BASIS_SURCHARGE_THRESHOLD") , false) ?) , super :: UdxEdxfSurchargeElementTypeContent :: UdxEdxfMaterialBasisSurchargeShutter (x) => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfMaterialBasisSurchargeShutter (WithSerializer :: serializer (x , Some ("UDX.EDXF.MATERIAL_BASIS_SURCHARGE_SHUTTER") , false) ?) , super :: UdxEdxfSurchargeElementTypeContent :: UdxEdxfMaterialBasisSurchargeCredit (x) => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfMaterialBasisSurchargeCredit (WithSerializer :: serializer (x , Some ("UDX.EDXF.MATERIAL_BASIS_SURCHARGE_CREDIT") , false) ?) , super :: UdxEdxfSurchargeElementTypeContent :: UdxEdxfMaterialBasisSurchargeTable (x) => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfMaterialBasisSurchargeTable (WithSerializer :: serializer (x , Some ("UDX.EDXF.MATERIAL_BASIS_SURCHARGE_TABLE") , false) ?) , } } UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfSurchargeType (x) => { match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: Done__ , } } UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfSurchargeManner (x) => { match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: Done__ , } } UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfSurchargePercentage (x) => { match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: Done__ , } } UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfSurchargePriceAmount (x) => { match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: Done__ , } } UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfSurchargeCalculation (x) => { match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: Done__ , } } UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfMaterialBasis (x) => { match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: Done__ , } } UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfMaterialBasisWeight (x) => { match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: Done__ , } } UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfMaterialBasisSurchargeThreshold (x) => { match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: Done__ , } } UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfMaterialBasisSurchargeShutter (x) => { match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: Done__ , } } UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfMaterialBasisSurchargeCredit (x) => { match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: Done__ , } } UdxEdxfSurchargeElementTypeContentSerializerState :: UdxEdxfMaterialBasisSurchargeTable (x) => { match x . next (helper) . transpose () ? { Some (event) => return Ok (Some (event)) , None => * self . state = UdxEdxfSurchargeElementTypeContentSerializerState :: Done__ , } } UdxEdxfSurchargeElementTypeContentSerializerState :: Done__ => return Ok (None) , UdxEdxfSurchargeElementTypeContentSerializerState :: Phantom__ (_) => unreachable ! () , }
            }
        }
    }
    impl<'ser> Serializer<'ser> for UdxEdxfSurchargeElementTypeContentSerializer<'ser> {
        fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
            match self.next_event(helper) {
                Ok(Some(event)) => Some(Ok(event)),
                Ok(None) => None,
                Err(error) => {
                    *self.state = UdxEdxfSurchargeElementTypeContentSerializerState::Done__;
                    Some(Err(error))
                }
            }
        }
    }
}