// Auto-generated by automapper-generator. Do not edit.

#![allow(unused_imports)]

use serde::{Deserialize, Serialize};
use super::entities::*;
use std::collections::BTreeMap;

/// Map key for Marktteilnehmer instances.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
pub enum MarktteilnehmerKey {
    /// Dokumenten-/Nachrichtenaussteller bzw. -absender
    #[serde(rename = "MS")]
    Ms,
    /// Nachrichtenempfänger
    #[serde(rename = "MR")]
    Mr,
}

impl std::fmt::Display for MarktteilnehmerKey {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Ms => write!(f, "MS"),
            Self::Mr => write!(f, "MR"),
        }
    }
}

/// Map key for Geschaeftspartner instances.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
pub enum GeschaeftspartnerKey {
    #[serde(rename = "Z04")]
    Z04,
    #[serde(rename = "Z09")]
    Z09,
}

impl std::fmt::Display for GeschaeftspartnerKey {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Z04 => write!(f, "Z04"),
            Self::Z09 => write!(f, "Z09"),
        }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55001MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55001: Anmeldung verb. MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55001TransaktionStammdaten {
    /// Required (Muss). Fields: anredeCode, nachname
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub ansprechpartner: Option<Vec<Ansprechpartner>>,
    /// Required (Muss). Fields: privilegierungsgrund, verringerungUmlage
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub enfg_daten: Option<Vec<EnfgDaten>>,
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.strasse, anredeCode, nadQualifier, name1, region
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: haushaltskunde, marktlokationsId, ruhendeMarktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: priorisierung.produktpaketRef, produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, produktMerkmal.code, produktMerkmal.eigenschaft, produktWert.code, produktWert.wert, umsetzungsgrad.klasse, umsetzungsgrad.prioritaet, umsetzungsgrad.relevanz, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub produktpaket_daten: Option<Vec<ProduktpaketDaten>>,
    /// Required (Muss). Fields: gueltigAb, gueltigBis, pruefidentifikator, transaktionsgrund, transaktionsgrundErgaenzung, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55001TransaktionStammdaten {
    /// Required entity fields for PID 55001 (Anmeldung verb. MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("ansprechpartner", &["anredeCode", "nachname"]),
            ("enfg_daten", &["privilegierungsgrund", "verringerungUmlage"]),
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.strasse", "anredeCode", "nadQualifier", "name1", "region"]),
            ("marktlokation", &["haushaltskunde", "marktlokationsId", "ruhendeMarktlokationsId"]),
            ("produktpaket_daten", &["priorisierung.produktpaketRef", "produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "produktMerkmal.code", "produktMerkmal.eigenschaft", "produktWert.code", "produktWert.wert", "umsetzungsgrad.klasse", "umsetzungsgrad.prioritaet", "umsetzungsgrad.relevanz", "zeitscheibe.referenz"]),
            ("prozessdaten", &["gueltigAb", "gueltigBis", "pruefidentifikator", "transaktionsgrund", "transaktionsgrundErgaenzung", "vorgangId"]),
        ]
    }
}

pub type Pid55001Interchange = crate::model::Interchange<
    Pid55001MessageStammdaten,
    Pid55001TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55002MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55002: Bestätigung Anmeldung verb. MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55002TransaktionStammdaten {
    /// Required (Muss). Fields: marktlokationsId, merkmal.code, merkmal.eigenschaft, merkmal.eigenschaft_2, merkmal.qualifier, ruhendeMarktlokationsId, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: gMsbMerkmalWert, gMsbMpId, merkmal.code, merkmal.eigenschaft, merkmal.eigenschaft_2, merkmal.qualifier, messlokationsId, referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.qualifier, netzlokationsId, referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: geplantesPaket, gueltigAb, gueltigBis, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.qualifier, referenz, steuerbareRessourceId, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    pub tranche: Option<Tranche>,
}

impl Pid55002TransaktionStammdaten {
    /// Required entity fields for PID 55002 (Bestätigung Anmeldung verb. MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["marktlokationsId", "merkmal.code", "merkmal.eigenschaft", "merkmal.eigenschaft_2", "merkmal.qualifier", "ruhendeMarktlokationsId", "zugeordneterMp"]),
            ("messlokation", &["gMsbMerkmalWert", "gMsbMpId", "merkmal.code", "merkmal.eigenschaft", "merkmal.eigenschaft_2", "merkmal.qualifier", "messlokationsId", "referenz", "zugeordneterMp"]),
            ("netzlokation", &["merkmal.code", "merkmal.eigenschaft", "merkmal.qualifier", "netzlokationsId", "referenz", "zugeordneterMp"]),
            ("prozessdaten", &["geplantesPaket", "gueltigAb", "gueltigBis", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
            ("steuerbare_ressource", &["merkmal.code", "merkmal.eigenschaft", "merkmal.qualifier", "referenz", "steuerbareRessourceId", "zugeordneterMp"]),
            ("technische_ressource", &["technischeRessourceId"]),
        ]
    }
}

pub type Pid55002Interchange = crate::model::Interchange<
    Pid55002MessageStammdaten,
    Pid55002TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55003MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55003: Ablehnung Anmeldung verb. MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55003TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktpartnerId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: datumNaechsteBearbeitung, gueltigAb, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55003TransaktionStammdaten {
    /// Required entity fields for PID 55003 (Ablehnung Anmeldung verb. MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("geschaeftspartner", &["codelisteCode", "codepflegeCode", "marktpartnerId"]),
            ("prozessdaten", &["datumNaechsteBearbeitung", "gueltigAb", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55003Interchange = crate::model::Interchange<
    Pid55003MessageStammdaten,
    Pid55003TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55004MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55004: Abmeldung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55004TransaktionStammdaten {
    /// Required (Muss). Fields: marktlokationsId, ruhendeMarktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: gueltigBis, pruefidentifikator, transaktionsgrund, transaktionsgrundErgaenzung, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
}

impl Pid55004TransaktionStammdaten {
    /// Required entity fields for PID 55004 (Abmeldung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["marktlokationsId", "ruhendeMarktlokationsId"]),
            ("prozessdaten", &["gueltigBis", "pruefidentifikator", "transaktionsgrund", "transaktionsgrundErgaenzung", "vorgangId"]),
            ("tranche", &["trancheId"]),
        ]
    }
}

pub type Pid55004Interchange = crate::model::Interchange<
    Pid55004MessageStammdaten,
    Pid55004TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55005MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55005: Bestätigung Abmeldung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55005TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: gueltigBis, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55005TransaktionStammdaten {
    /// Required entity fields for PID 55005 (Bestätigung Abmeldung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["gueltigBis", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55005Interchange = crate::model::Interchange<
    Pid55005MessageStammdaten,
    Pid55005TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55006MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55006: Ablehnung Abmeldung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55006TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55006TransaktionStammdaten {
    /// Required entity fields for PID 55006 (Ablehnung Abmeldung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55006Interchange = crate::model::Interchange<
    Pid55006MessageStammdaten,
    Pid55006TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55007MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55007: Abmeldung / Beendig-ung der Zuordnung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55007TransaktionStammdaten {
    /// Required (Muss). Fields: marktlokationsId, ruhendeMarktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: belieferungsende, gueltigBis, pruefidentifikator, transaktionsgrund, transaktionsgrundErgaenzung, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
}

impl Pid55007TransaktionStammdaten {
    /// Required entity fields for PID 55007 (Abmeldung / Beendig-ung der Zuordnung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["marktlokationsId", "ruhendeMarktlokationsId"]),
            ("prozessdaten", &["belieferungsende", "gueltigBis", "pruefidentifikator", "transaktionsgrund", "transaktionsgrundErgaenzung", "transaktionsnummer", "vorgangId"]),
            ("tranche", &["trancheId"]),
        ]
    }
}

pub type Pid55007Interchange = crate::model::Interchange<
    Pid55007MessageStammdaten,
    Pid55007TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55008MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55008: Bestätigung Abmeldung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55008TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: belieferungsende, gueltigBis, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55008TransaktionStammdaten {
    /// Required entity fields for PID 55008 (Bestätigung Abmeldung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["belieferungsende", "gueltigBis", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55008Interchange = crate::model::Interchange<
    Pid55008MessageStammdaten,
    Pid55008TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55009MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55009: Ablehnung Abmeldung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55009TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55009TransaktionStammdaten {
    /// Required entity fields for PID 55009 (Ablehnung Abmeldung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55009Interchange = crate::model::Interchange<
    Pid55009MessageStammdaten,
    Pid55009TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55010MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55010: Anfrage zur Beendigung der Zuordnung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55010TransaktionStammdaten {
    /// Required (Muss). Fields: anredeCode, nachname
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub ansprechpartner: Option<Vec<Ansprechpartner>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktpartnerId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: marktlokationsId, ruhendeMarktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: annahmedatum, gueltigBis, pruefidentifikator, transaktionsgrund, transaktionsgrundErgaenzung, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
}

impl Pid55010TransaktionStammdaten {
    /// Required entity fields for PID 55010 (Anfrage zur Beendigung der Zuordnung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("ansprechpartner", &["anredeCode", "nachname"]),
            ("geschaeftspartner", &["codelisteCode", "codepflegeCode", "marktpartnerId"]),
            ("marktlokation", &["marktlokationsId", "ruhendeMarktlokationsId"]),
            ("prozessdaten", &["annahmedatum", "gueltigBis", "pruefidentifikator", "transaktionsgrund", "transaktionsgrundErgaenzung", "vorgangId"]),
            ("tranche", &["trancheId"]),
        ]
    }
}

pub type Pid55010Interchange = crate::model::Interchange<
    Pid55010MessageStammdaten,
    Pid55010TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55011MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55011: Bestätigung Beendigung der Zuordnung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55011TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: gueltigBis, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55011TransaktionStammdaten {
    /// Required entity fields for PID 55011 (Bestätigung Beendigung der Zuordnung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["gueltigBis", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55011Interchange = crate::model::Interchange<
    Pid55011MessageStammdaten,
    Pid55011TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55012MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55012: Ablehnung Beendigung der Zuordnung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55012TransaktionStammdaten {
    /// Optional.
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55012TransaktionStammdaten {
    /// Required entity fields for PID 55012 (Ablehnung Beendigung der Zuordnung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55012Interchange = crate::model::Interchange<
    Pid55012MessageStammdaten,
    Pid55012TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55013MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55013: Anmeldung / Zuordnung EOG
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55013TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.postleitzahl, anredeCode, geschaeftspartnerId, name1, partnerrolle, region
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    /// Required (Muss). Fields: messlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: netzlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: gueltigAb, gueltigBis, pruefidentifikator, transaktionsgrund, transaktionsgrundErgaenzung, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: referenz, steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.eigenschaft_2, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55013TransaktionStammdaten {
    /// Required entity fields for PID 55013 (Anmeldung / Zuordnung EOG).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.postleitzahl", "anredeCode", "geschaeftspartnerId", "name1", "partnerrolle", "region"]),
            ("marktlokation", &["marktlokationsId"]),
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("messlokation", &["messlokationsId", "referenz"]),
            ("netzlokation", &["netzlokationsId", "referenz"]),
            ("prozessdaten", &["gueltigAb", "gueltigBis", "pruefidentifikator", "transaktionsgrund", "transaktionsgrundErgaenzung", "transaktionsnummer", "vorgangId"]),
            ("steuerbare_ressource", &["referenz", "steuerbareRessourceId"]),
            ("technische_ressource", &["technischeRessourceId"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.eigenschaft_2", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55013Interchange = crate::model::Interchange<
    Pid55013MessageStammdaten,
    Pid55013TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55014MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55014: Bestätigung EOG Anmeldung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55014TransaktionStammdaten {
    /// Required (Muss). Fields: anredeCode, nachname
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub ansprechpartner: Option<Vec<Ansprechpartner>>,
    /// Required (Muss).
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub enfg_daten: Option<Vec<EnfgDaten>>,
    /// Required (Muss). Fields: anredeCode, land, nachname, ort, region, strasse
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss).
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub produktpaket_daten: Option<Vec<ProduktpaketDaten>>,
    /// Required (Muss). Fields: antwortKategorie, gueltigAb, gueltigBis, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundErgaenzung, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55014TransaktionStammdaten {
    /// Required entity fields for PID 55014 (Bestätigung EOG Anmeldung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("ansprechpartner", &["anredeCode", "nachname"]),
            ("geschaeftspartner", &["anredeCode", "land", "nachname", "ort", "region", "strasse"]),
            ("produktpaket_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
            ("prozessdaten", &["antwortKategorie", "gueltigAb", "gueltigBis", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundErgaenzung", "transaktionsnummer", "vorgangId"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55014Interchange = crate::model::Interchange<
    Pid55014MessageStammdaten,
    Pid55014TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55015MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55015: Ablehnung EOG Anmeldung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55015TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: antwortKategorie, freitext, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundErgaenzung, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55015TransaktionStammdaten {
    /// Required entity fields for PID 55015 (Ablehnung EOG Anmeldung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["antwortKategorie", "freitext", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundErgaenzung", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55015Interchange = crate::model::Interchange<
    Pid55015MessageStammdaten,
    Pid55015TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55016MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55016: Kündigung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55016TransaktionStammdaten {
    /// Required (Muss). Fields: marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: gueltigBis, transaktionsgrund, transaktionsgrundErgaenzung, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
}

impl Pid55016TransaktionStammdaten {
    /// Required entity fields for PID 55016 (Kündigung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["marktlokationsId"]),
            ("prozessdaten", &["gueltigBis", "transaktionsgrund", "transaktionsgrundErgaenzung", "vorgangId"]),
            ("tranche", &["trancheId"]),
        ]
    }
}

pub type Pid55016Interchange = crate::model::Interchange<
    Pid55016MessageStammdaten,
    Pid55016TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55017MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55017: Bestätigung Kündigung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55017TransaktionStammdaten {
    /// Required (Muss). Fields: mengenangabe
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: antwortKategorie, gueltigBis, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundErgaenzung, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55017TransaktionStammdaten {
    /// Required entity fields for PID 55017 (Bestätigung Kündigung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["mengenangabe"]),
            ("prozessdaten", &["antwortKategorie", "gueltigBis", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundErgaenzung", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55017Interchange = crate::model::Interchange<
    Pid55017MessageStammdaten,
    Pid55017TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55018MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55018: Ablehnung Kündigung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55018TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: antwortKategorie, bestaetigterKuendigungsterminKunde, einzugsDatum, freitext, kuendigungsfrist, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55018TransaktionStammdaten {
    /// Required entity fields for PID 55018 (Ablehnung Kündigung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["antwortKategorie", "bestaetigterKuendigungsterminKunde", "einzugsDatum", "freitext", "kuendigungsfrist", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55018Interchange = crate::model::Interchange<
    Pid55018MessageStammdaten,
    Pid55018TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55022MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55022: Anfrage nach Stornierung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55022TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: freitext, pruefidentifikator, referenz, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55022TransaktionStammdaten {
    /// Required entity fields for PID 55022 (Anfrage nach Stornierung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["freitext", "pruefidentifikator", "referenz", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55022Interchange = crate::model::Interchange<
    Pid55022MessageStammdaten,
    Pid55022TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55023MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55023: Bestätigung Anfrage Stornierung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55023TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: antwortKategorie, pruefidentifikator, pruefschrittCode, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55023TransaktionStammdaten {
    /// Required entity fields for PID 55023 (Bestätigung Anfrage Stornierung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["antwortKategorie", "pruefidentifikator", "pruefschrittCode", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55023Interchange = crate::model::Interchange<
    Pid55023MessageStammdaten,
    Pid55023TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55024MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55024: Ablehnung Anfrage Stornierung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55024TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: antwortKategorie, freitext, pruefidentifikator, pruefschrittCode, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55024TransaktionStammdaten {
    /// Required entity fields for PID 55024 (Ablehnung Anfrage Stornierung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["antwortKategorie", "freitext", "pruefidentifikator", "pruefschrittCode", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55024Interchange = crate::model::Interchange<
    Pid55024MessageStammdaten,
    Pid55024TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55035MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55035: Antwort auf GDA verb. MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55035TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.postleitzahl, anrede, codelist_code, codepflege_code, geschaeftspartnerId, name1, name2, name3, name_format_code, region
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: lokationsbuendelId, marktlokationsId, marktlokationsIds, messlokationsId, messlokationsIdRefs, netzlokationsId, technischeRessourceId, technischeRessourceIdRefs
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub lokationsbuendel_zuordnung: Option<Vec<LokationsbuendelZuordnungWrapped>>,
    /// Required (Muss). Fields: marktlokationsId, ruhendeMarktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation_daten: Option<Vec<MarktlokationDatenWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    /// Required (Muss). Fields: messlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: netzlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation_daten: Option<Vec<NetzlokationDatenWrapped>>,
    /// Required (Muss). Fields: artProduktCode, produktIdentifikation.id
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netznutzungsabrechnungsdaten: Option<Vec<NetznutzungsabrechnungsdatenWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub netznutzungsabrechnungsdaten_mengen: Option<NetznutzungsabrechnungsdatenMengenWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, transaktionsgrundErgaenzung, vorgangId, vorgangsnummer
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource_daten: Option<Vec<SteuerbareRessourceDatenWrapped>>,
    /// Required (Muss). Fields: technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    /// Required (Muss). Fields: referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource_daten: Option<Vec<TechnischeRessourceDatenWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub technische_ressource_mengen: Option<TechnischeRessourceMengenWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler_daten: Option<Vec<ZaehlerDatenWrapped>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.code_codepflege, merkmal.codeliste, merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55035TransaktionStammdaten {
    /// Required entity fields for PID 55035 (Antwort auf GDA verb. MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.postleitzahl", "anrede", "codelist_code", "codepflege_code", "geschaeftspartnerId", "name1", "name2", "name3", "name_format_code", "region"]),
            ("lokationsbuendel_zuordnung", &["lokationsbuendelId", "marktlokationsId", "marktlokationsIds", "messlokationsId", "messlokationsIdRefs", "netzlokationsId", "technischeRessourceId", "technischeRessourceIdRefs"]),
            ("marktlokation", &["marktlokationsId", "ruhendeMarktlokationsId"]),
            ("marktlokation_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ"]),
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("messlokation", &["messlokationsId", "referenz"]),
            ("netzlokation", &["netzlokationsId"]),
            ("netzlokation_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ"]),
            ("netznutzungsabrechnungsdaten", &["artProduktCode", "produktIdentifikation.id"]),
            ("netznutzungsabrechnungsdaten_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "transaktionsgrundErgaenzung", "vorgangId", "vorgangsnummer"]),
            ("steuerbare_ressource", &["steuerbareRessourceId"]),
            ("steuerbare_ressource_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ"]),
            ("technische_ressource", &["technischeRessourceId"]),
            ("technische_ressource_daten", &["referenz"]),
            ("technische_ressource_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("zaehler_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.code_codepflege", "merkmal.codeliste", "merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55035Interchange = crate::model::Interchange<
    Pid55035MessageStammdaten,
    Pid55035TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55036MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55036: Existierende Zuordnung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55036TransaktionStammdaten {
    /// Required (Muss). Fields: codelist_code, codepflege_code, identifikation, partnerrolle
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
}

impl Pid55036TransaktionStammdaten {
    /// Required entity fields for PID 55036 (Existierende Zuordnung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["codelist_code", "codepflege_code", "identifikation", "partnerrolle"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
        ]
    }
}

pub type Pid55036Interchange = crate::model::Interchange<
    Pid55036MessageStammdaten,
    Pid55036TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55037MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55037: Beendigung der Zuordnung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55037TransaktionStammdaten {
    /// Required (Muss). Fields: marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: gueltigBis, pruefidentifikator, transaktionsgrund, transaktionsgrundErgaenzung, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
}

impl Pid55037TransaktionStammdaten {
    /// Required entity fields for PID 55037 (Beendigung der Zuordnung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["marktlokationsId"]),
            ("prozessdaten", &["gueltigBis", "pruefidentifikator", "transaktionsgrund", "transaktionsgrundErgaenzung", "vorgangId"]),
            ("tranche", &["trancheId"]),
        ]
    }
}

pub type Pid55037Interchange = crate::model::Interchange<
    Pid55037MessageStammdaten,
    Pid55037TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55038MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55038: Aufhebung einer zuk. Zuordnung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55038TransaktionStammdaten {
    /// Required (Muss). Fields: codelist_code, codepflege_code, identifikation, partnerrolle
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: gueltigAb, pruefidentifikator, transaktionsgrund, transaktionsgrundErgaenzung, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
}

impl Pid55038TransaktionStammdaten {
    /// Required entity fields for PID 55038 (Aufhebung einer zuk. Zuordnung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["codelist_code", "codepflege_code", "identifikation", "partnerrolle"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("prozessdaten", &["gueltigAb", "pruefidentifikator", "transaktionsgrund", "transaktionsgrundErgaenzung", "vorgangId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
        ]
    }
}

pub type Pid55038Interchange = crate::model::Interchange<
    Pid55038MessageStammdaten,
    Pid55038TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55039MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55039: Kündigung MSB
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55039TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.postleitzahl, anredeCode, name1, partnerrolle
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: abrechnungsperiode, gueltigBis, ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler: Option<Vec<ZaehlerWrapped>>,
}

impl Pid55039TransaktionStammdaten {
    /// Required entity fields for PID 55039 (Kündigung MSB).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.postleitzahl", "anredeCode", "name1", "partnerrolle"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "messlokationsId"]),
            ("prozessdaten", &["abrechnungsperiode", "gueltigBis", "ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("zaehler", &["merkmal.code", "merkmal.eigenschaft"]),
        ]
    }
}

pub type Pid55039Interchange = crate::model::Interchange<
    Pid55039MessageStammdaten,
    Pid55039TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55040MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55040: Bestätigung Kündigung MSB
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55040TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.postleitzahl, anredeCode, codelisteCode, codepflegeCode, geschaeftspartnerId, name1, partnerrolle, referenz, region
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: abrechnungsperiode, gueltigBis, ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler: Option<Vec<ZaehlerWrapped>>,
}

impl Pid55040TransaktionStammdaten {
    /// Required entity fields for PID 55040 (Bestätigung Kündigung MSB).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.postleitzahl", "anredeCode", "codelisteCode", "codepflegeCode", "geschaeftspartnerId", "name1", "partnerrolle", "referenz", "region"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "messlokationsId"]),
            ("prozessdaten", &["abrechnungsperiode", "gueltigBis", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("zaehler", &["merkmal.code", "merkmal.eigenschaft", "referenz"]),
        ]
    }
}

pub type Pid55040Interchange = crate::model::Interchange<
    Pid55040MessageStammdaten,
    Pid55040TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55041MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55041: Ablehnung Kündigung MSB
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55041TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: beginndatum, ideQualifier, kuendigungsfrist, kuendigungstermin, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55041TransaktionStammdaten {
    /// Required entity fields for PID 55041 (Ablehnung Kündigung MSB).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["codelisteCode", "codepflegeCode", "messlokationsId"]),
            ("prozessdaten", &["beginndatum", "ideQualifier", "kuendigungsfrist", "kuendigungstermin", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55041Interchange = crate::model::Interchange<
    Pid55041MessageStammdaten,
    Pid55041TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55042MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55042: Anmeldung MSB
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55042TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.postleitzahl, anredeCode, name1, partnerrolle
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: codelisteCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: codelisteCode, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: geplanterLieferbeginn, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: geraeteCode, geraeteNummer, zaehlertypMerkmal
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler: Option<Vec<ZaehlerWrapped>>,
}

impl Pid55042TransaktionStammdaten {
    /// Required entity fields for PID 55042 (Anmeldung MSB).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.postleitzahl", "anredeCode", "name1", "partnerrolle"]),
            ("marktlokation", &["codelisteCode", "marktlokationsId"]),
            ("messlokation", &["codelisteCode", "messlokationsId"]),
            ("prozessdaten", &["geplanterLieferbeginn", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("zaehler", &["geraeteCode", "geraeteNummer", "zaehlertypMerkmal"]),
        ]
    }
}

pub type Pid55042Interchange = crate::model::Interchange<
    Pid55042MessageStammdaten,
    Pid55042TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55043MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55043: Bestätigung Anmeldung MSB
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55043TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.postleitzahl, anredeCode, codelisteCode, codepflegeCode, geschaeftspartnerId, name1, partnerrolle, referenz, region, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub lokationsbuendel_daten: Option<Vec<LokationsbuendelDatenWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, referenz, ruhendeMarktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub mengen_daten: Option<Vec<MengenDaten>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub mengen_daten_erw: Option<Vec<MengenDatenErw>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, jahresverbrauchsprognose, mengeneinheit, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation_daten: Option<Vec<MesslokationDatenWrapped>>,
    /// Required (Muss). Fields: netzlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl: Option<Vec<ObisKennzahlWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_marktlokation: Option<Vec<ObisMarktlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_zaehleinrichtung: Option<Vec<ObisZaehleinrichtungWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub produktpaket_daten: Option<Vec<ProduktpaketDaten>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub profil_daten: Option<Vec<ProfilDaten>>,
    /// Required (Muss). Fields: datumZ50, geplanterLieferbeginn, ideQualifier, pruefidentifikator, pruefschrittCode, referenz, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub referenzprofil: Option<Vec<Referenzprofil>>,
    /// Required (Muss). Fields: steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource_daten: Option<Vec<SteuerbareRessourceDatenWrapped>>,
    /// Required (Muss). Fields: referenz, technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler_daten: Option<Vec<ZaehlerDatenWrapped>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.code_codepflege, merkmal.codeliste, merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55043TransaktionStammdaten {
    /// Required entity fields for PID 55043 (Bestätigung Anmeldung MSB).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.postleitzahl", "anredeCode", "codelisteCode", "codepflegeCode", "geschaeftspartnerId", "name1", "partnerrolle", "referenz", "region", "zeitscheibe.referenz"]),
            ("lokationsbuendel_daten", &["referenz"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "referenz", "ruhendeMarktlokationsId"]),
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("mengen_daten", &["produktIdentifikation.id", "referenz"]),
            ("mengen_daten_erw", &["produktIdentifikation.id", "referenz"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "jahresverbrauchsprognose", "mengeneinheit", "messlokationsId"]),
            ("messlokation_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ"]),
            ("netzlokation", &["netzlokationsId", "referenz"]),
            ("obis_kennzahl", &["produktIdentifikation.id", "referenz"]),
            ("obis_marktlokation", &["produktIdentifikation.id", "referenz"]),
            ("obis_zaehleinrichtung", &["produktIdentifikation.id", "referenz"]),
            ("produktpaket_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ", "zeitscheibe.referenz"]),
            ("profil_daten", &["referenz.id", "referenz.typ"]),
            ("prozessdaten", &["datumZ50", "geplanterLieferbeginn", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "referenz", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("referenzprofil", &["referenz"]),
            ("steuerbare_ressource", &["steuerbareRessourceId"]),
            ("steuerbare_ressource_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ"]),
            ("technische_ressource", &["referenz", "technischeRessourceId"]),
            ("tranche", &["trancheId"]),
            ("zaehler_daten", &["referenz.id", "referenz.typ"]),
            ("zuordnung", &["merkmal.code", "merkmal.code_codepflege", "merkmal.codeliste", "merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55043Interchange = crate::model::Interchange<
    Pid55043MessageStammdaten,
    Pid55043TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55044MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55044: Ablehnung Anmeldung MSB
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55044TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55044TransaktionStammdaten {
    /// Required entity fields for PID 55044 (Ablehnung Anmeldung MSB).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["codelisteCode", "codepflegeCode", "messlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55044Interchange = crate::model::Interchange<
    Pid55044MessageStammdaten,
    Pid55044TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55051MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55051: Ende MSB
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55051TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: gueltigAb, gueltigBis, ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55051TransaktionStammdaten {
    /// Required entity fields for PID 55051 (Ende MSB).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["codelisteCode", "codepflegeCode", "messlokationsId"]),
            ("prozessdaten", &["gueltigAb", "gueltigBis", "ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55051Interchange = crate::model::Interchange<
    Pid55051MessageStammdaten,
    Pid55051TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55052MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55052: Bestätigung Ende MSB
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55052TransaktionStammdaten {
    /// Required (Muss). Fields: marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: netzlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: gueltigAb, gueltigBis, ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
}

impl Pid55052TransaktionStammdaten {
    /// Required entity fields for PID 55052 (Bestätigung Ende MSB).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["marktlokationsId"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "messlokationsId"]),
            ("netzlokation", &["netzlokationsId"]),
            ("prozessdaten", &["gueltigAb", "gueltigBis", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("steuerbare_ressource", &["steuerbareRessourceId"]),
            ("technische_ressource", &["technischeRessourceId"]),
            ("tranche", &["trancheId"]),
        ]
    }
}

pub type Pid55052Interchange = crate::model::Interchange<
    Pid55052MessageStammdaten,
    Pid55052TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55053MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55053: Ablehnung Ende MSB
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55053TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55053TransaktionStammdaten {
    /// Required entity fields for PID 55053 (Ablehnung Ende MSB).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["codelisteCode", "codepflegeCode", "messlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55053Interchange = crate::model::Interchange<
    Pid55053MessageStammdaten,
    Pid55053TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55060MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55060: Antwort auf GDA
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55060TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.postleitzahl, anrede, codelisteCode, codepflegeCode, geschaeftspartnerId, name1, name2, nameZeile3Feld, nameZeile4Feld, partnerrolle, referenz, region
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: marktlokationsId, messlokationsId, netzlokationsId, referenz, technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub lokationsbuendel_zuordnung: Option<Vec<LokationsbuendelZuordnungWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, jahresverbrauchsprognose, marktlokationsId, mengeneinheit, ruhendeMarktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation_daten: Option<Vec<MarktlokationDatenWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation_daten: Option<Vec<MesslokationDatenWrapped>>,
    /// Required (Muss). Fields: netzlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation_daten: Option<Vec<NetzlokationDatenWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netznutzungsabrechnungsdaten_erw: Option<Vec<NetznutzungsabrechnungsdatenErwWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, referenz, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource_daten: Option<Vec<SteuerbareRessourceDatenWrapped>>,
    /// Required (Muss). Fields: referenz, technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler_daten: Option<Vec<ZaehlerDatenWrapped>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55060TransaktionStammdaten {
    /// Required entity fields for PID 55060 (Antwort auf GDA).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.postleitzahl", "anrede", "codelisteCode", "codepflegeCode", "geschaeftspartnerId", "name1", "name2", "nameZeile3Feld", "nameZeile4Feld", "partnerrolle", "referenz", "region"]),
            ("lokationsbuendel_zuordnung", &["marktlokationsId", "messlokationsId", "netzlokationsId", "referenz", "technischeRessourceId"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "jahresverbrauchsprognose", "marktlokationsId", "mengeneinheit", "ruhendeMarktlokationsId"]),
            ("marktlokation_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ"]),
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "messlokationsId"]),
            ("messlokation_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ"]),
            ("netzlokation", &["netzlokationsId"]),
            ("netzlokation_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz", "referenz.id", "referenz.typ"]),
            ("netznutzungsabrechnungsdaten_erw", &["produktIdentifikation.id", "referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "referenz", "transaktionsgrund", "vorgangId"]),
            ("steuerbare_ressource", &["steuerbareRessourceId"]),
            ("steuerbare_ressource_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ"]),
            ("technische_ressource", &["referenz", "technischeRessourceId"]),
            ("tranche", &["trancheId"]),
            ("zaehler_daten", &["referenz.id", "referenz.typ"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55060Interchange = crate::model::Interchange<
    Pid55060MessageStammdaten,
    Pid55060TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55062MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55062: Aktivierung von ZP
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55062TransaktionStammdaten {
    /// Required (Muss). Fields: produktIdentifikation.id
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub clearing_daten: Option<Vec<ClearingDaten>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungVon, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55062TransaktionStammdaten {
    /// Required entity fields for PID 55062 (Aktivierung von ZP).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("clearing_daten", &["produktIdentifikation.id"]),
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungVon", "ideQualifier", "pruefidentifikator", "vorgangId"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55062Interchange = crate::model::Interchange<
    Pid55062MessageStammdaten,
    Pid55062TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55063MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55063: Deaktivier-ung von ZP
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55063TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungBis, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55063TransaktionStammdaten {
    /// Required entity fields for PID 55063 (Deaktivier-ung von ZP).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungBis", "ideQualifier", "pruefidentifikator", "vorgangId"]),
        ]
    }
}

pub type Pid55063Interchange = crate::model::Interchange<
    Pid55063MessageStammdaten,
    Pid55063TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55064MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55064: Antwort
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55064TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungBis, aenderungVon, ebdNummer, ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55064TransaktionStammdaten {
    /// Required entity fields for PID 55064 (Antwort).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungBis", "aenderungVon", "ebdNummer", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55064Interchange = crate::model::Interchange<
    Pid55064MessageStammdaten,
    Pid55064TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55065MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55065: Lieferanten-clearingliste
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55065TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    /// Required (Muss). Fields: jahresverbrauchsprognose, mabisZaehlpunktId, mengeneinheit
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: referenz, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub profil_daten: Option<Vec<ProfilDaten>>,
    /// Required (Muss). Fields: aenderungBis, aenderungVon, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub referenzprofil: Option<Vec<Referenzprofil>>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: referenz.id, referenz.typ, zeitscheibe.referenz
    pub summenzeitreihen_daten: Option<SummenzeitreihenDaten>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche_daten: Option<Vec<TrancheDaten>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55065TransaktionStammdaten {
    /// Required entity fields for PID 55065 (Lieferanten-clearingliste).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "referenz"]),
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("messlokation", &["jahresverbrauchsprognose", "mabisZaehlpunktId", "mengeneinheit"]),
            ("profil_daten", &["referenz", "referenz.id", "referenz.typ"]),
            ("prozessdaten", &["aenderungBis", "aenderungVon", "ideQualifier", "pruefidentifikator", "vorgangId"]),
            ("referenzprofil", &["referenz"]),
            ("summenzeitreihen_daten", &["referenz.id", "referenz.typ", "zeitscheibe.referenz"]),
            ("tranche", &["trancheId"]),
            ("tranche_daten", &["referenz.id", "referenz.typ"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55065Interchange = crate::model::Interchange<
    Pid55065MessageStammdaten,
    Pid55065TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55066MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55066: Korrekturliste zur Lieferanten-clearingliste
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55066TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    /// Required (Muss). Fields: jahresverbrauchsprognose, mabisZaehlpunktId, mengeneinheit
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: referenz, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub profil_daten: Option<Vec<ProfilDaten>>,
    /// Required (Muss). Fields: aenderungBis, aenderungVon, ebdNummer, ebdNummer2, ideQualifier, pruefidentifikator, pruefschrittCode, pruefschrittCode2, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub referenzprofil: Option<Vec<Referenzprofil>>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: referenz.id, referenz.typ, zeitscheibe.referenz
    pub summenzeitreihen_daten: Option<SummenzeitreihenDaten>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche_daten: Option<Vec<TrancheDaten>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55066TransaktionStammdaten {
    /// Required entity fields for PID 55066 (Korrekturliste zur Lieferanten-clearingliste).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "referenz"]),
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("messlokation", &["jahresverbrauchsprognose", "mabisZaehlpunktId", "mengeneinheit"]),
            ("profil_daten", &["referenz", "referenz.id", "referenz.typ"]),
            ("prozessdaten", &["aenderungBis", "aenderungVon", "ebdNummer", "ebdNummer2", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "pruefschrittCode2", "transaktionsnummer", "vorgangId"]),
            ("referenzprofil", &["referenz"]),
            ("summenzeitreihen_daten", &["referenz.id", "referenz.typ", "zeitscheibe.referenz"]),
            ("tranche", &["trancheId"]),
            ("tranche_daten", &["referenz.id", "referenz.typ"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55066Interchange = crate::model::Interchange<
    Pid55066MessageStammdaten,
    Pid55066TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55067MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55067: Bilanzkreiszuordnungsliste
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55067TransaktionStammdaten {
    /// Required (Muss). Fields: produktIdentifikation.id
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub clearing_daten: Option<Vec<ClearingDaten>>,
    /// Required (Muss). Fields: adresse.hausnummer, adresse.landescode, adresse.ort, adresse.postleitzahl, adresse.strasse, anrede, codelisteCode, codepflegeCode, geschaeftspartnerId, name1, name2, nameZeile3Feld, nameZeile4Feld, partnerrolle, region, strasseZeile2, strasseZeile4, zusatzinfo
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId, merkmal.code, merkmal.klasse, merkmal.qualifier, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ebdNummer, ideQualifier, pruefidentifikator, pruefschrittCode, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55067TransaktionStammdaten {
    /// Required entity fields for PID 55067 (Bilanzkreiszuordnungsliste).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("clearing_daten", &["produktIdentifikation.id"]),
            ("geschaeftspartner", &["adresse.hausnummer", "adresse.landescode", "adresse.ort", "adresse.postleitzahl", "adresse.strasse", "anrede", "codelisteCode", "codepflegeCode", "geschaeftspartnerId", "name1", "name2", "nameZeile3Feld", "nameZeile4Feld", "partnerrolle", "region", "strasseZeile2", "strasseZeile4", "zusatzinfo"]),
            ("messlokation", &["mabisZaehlpunktId", "merkmal.code", "merkmal.klasse", "merkmal.qualifier", "referenz"]),
            ("prozessdaten", &["ebdNummer", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "vorgangId"]),
        ]
    }
}

pub type Pid55067Interchange = crate::model::Interchange<
    Pid55067MessageStammdaten,
    Pid55067TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55069MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55069: Clearingliste DZR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55069TransaktionStammdaten {
    /// Required (Muss). Fields: produktIdentifikation.id
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub clearing_daten: Option<Vec<ClearingDaten>>,
    /// Required (Muss). Fields: jahresverbrauchsprognose, mengeneinheit, prognose_zeitraum.beginn, prognose_zeitraum.ende
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId, merkmal.code, merkmal.klasse, merkmal.qualifier, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55069TransaktionStammdaten {
    /// Required entity fields for PID 55069 (Clearingliste DZR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("clearing_daten", &["produktIdentifikation.id"]),
            ("marktlokation", &["jahresverbrauchsprognose", "mengeneinheit", "prognose_zeitraum.beginn", "prognose_zeitraum.ende"]),
            ("messlokation", &["mabisZaehlpunktId", "merkmal.code", "merkmal.klasse", "merkmal.qualifier", "referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "vorgangId"]),
        ]
    }
}

pub type Pid55069Interchange = crate::model::Interchange<
    Pid55069MessageStammdaten,
    Pid55069TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55070MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55070: Clearingliste BAS
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55070TransaktionStammdaten {
    /// Required (Muss). Fields: produktIdentifikation.id
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub clearing_daten: Option<Vec<ClearingDaten>>,
    /// Required (Muss). Fields: jahresverbrauchsprognose, mengeneinheit, prognose_zeitraum.beginn, prognose_zeitraum.ende
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub redispatch_daten: Option<Vec<RedispatchDaten>>,
    /// Required (Muss). Fields: produktIdentifikation.id, produktIdentifikation.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub redispatch_daten_erw: Option<Vec<RedispatchDatenErw>>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55070TransaktionStammdaten {
    /// Required entity fields for PID 55070 (Clearingliste BAS).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("clearing_daten", &["produktIdentifikation.id"]),
            ("marktlokation", &["jahresverbrauchsprognose", "mengeneinheit", "prognose_zeitraum.beginn", "prognose_zeitraum.ende"]),
            ("messlokation", &["mabisZaehlpunktId", "referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "vorgangId"]),
            ("redispatch_daten", &["referenz"]),
            ("redispatch_daten_erw", &["produktIdentifikation.id", "produktIdentifikation.typ"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55070Interchange = crate::model::Interchange<
    Pid55070MessageStammdaten,
    Pid55070TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55071MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55071: Aktivierung der Zuordnungs-ermächtigung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55071TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.hausnummer, adresse.landescode, adresse.ort, adresse.postleitzahl, adresse.strasse, anrede, codelisteCode, codepflegeCode, geschaeftspartnerId, name1, name2, nameZeile3Feld, nameZeile4Feld, partnerrolle, region, strasseZeile2, strasseZeile4, zusatzinfo
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungVon, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55071TransaktionStammdaten {
    /// Required entity fields for PID 55071 (Aktivierung der Zuordnungs-ermächtigung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.hausnummer", "adresse.landescode", "adresse.ort", "adresse.postleitzahl", "adresse.strasse", "anrede", "codelisteCode", "codepflegeCode", "geschaeftspartnerId", "name1", "name2", "nameZeile3Feld", "nameZeile4Feld", "partnerrolle", "region", "strasseZeile2", "strasseZeile4", "zusatzinfo"]),
            ("messlokation", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
            ("prozessdaten", &["aenderungVon", "ideQualifier", "pruefidentifikator", "vorgangId"]),
        ]
    }
}

pub type Pid55071Interchange = crate::model::Interchange<
    Pid55071MessageStammdaten,
    Pid55071TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55072MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55072: Deaktivierung der Zuordnungs-ermächtigung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55072TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.hausnummer, adresse.landescode, adresse.ort, adresse.postleitzahl, adresse.strasse, anrede, codelisteCode, codepflegeCode, geschaeftspartnerId, name1, name2, nameZeile3Feld, nameZeile4Feld, partnerrolle, region, strasseZeile2, strasseZeile4, zusatzinfo
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungBis, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55072TransaktionStammdaten {
    /// Required entity fields for PID 55072 (Deaktivierung der Zuordnungs-ermächtigung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.hausnummer", "adresse.landescode", "adresse.ort", "adresse.postleitzahl", "adresse.strasse", "anrede", "codelisteCode", "codepflegeCode", "geschaeftspartnerId", "name1", "name2", "nameZeile3Feld", "nameZeile4Feld", "partnerrolle", "region", "strasseZeile2", "strasseZeile4", "zusatzinfo"]),
            ("messlokation", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
            ("prozessdaten", &["aenderungBis", "ideQualifier", "pruefidentifikator", "vorgangId"]),
        ]
    }
}

pub type Pid55072Interchange = crate::model::Interchange<
    Pid55072MessageStammdaten,
    Pid55072TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55073MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55073: Übermittlung der Profildefinitionen
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55073TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: menge, mengenQualifier
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub profil_daten: Option<Vec<ProfilDaten>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss).
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub referenzprofil: Option<Vec<Referenzprofil>>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: merkmal.code, merkmal.code_codepflege, merkmal.codeliste, merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55073TransaktionStammdaten {
    /// Required entity fields for PID 55073 (Übermittlung der Profildefinitionen).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("marktlokation_mengen", &["menge", "mengenQualifier"]),
            ("profil_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "vorgangId"]),
            ("zuordnung", &["merkmal.code", "merkmal.code_codepflege", "merkmal.codeliste", "merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55073Interchange = crate::model::Interchange<
    Pid55073MessageStammdaten,
    Pid55073TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55074MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55074: Stammdaten auf eine ORDERS
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55074TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.postleitzahl, partnerrolle
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, jahresverbrauchsprognose, mengeneinheit, messlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl_daten: Option<Vec<ObisKennzahlDatenWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_marktlokation: Option<Vec<ObisMarktlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_zaehleinrichtung: Option<Vec<ObisZaehleinrichtungWrapped>>,
    /// Required (Muss). Fields: beginndatum, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler_daten: Option<Vec<ZaehlerDatenWrapped>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.code_codepflege, merkmal.codeliste, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55074TransaktionStammdaten {
    /// Required entity fields for PID 55074 (Stammdaten auf eine ORDERS).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.postleitzahl", "partnerrolle"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "referenz"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "jahresverbrauchsprognose", "mengeneinheit", "messlokationsId", "referenz"]),
            ("obis_kennzahl_daten", &["produktIdentifikation.id", "referenz"]),
            ("obis_marktlokation", &["produktIdentifikation.id", "referenz"]),
            ("obis_zaehleinrichtung", &["produktIdentifikation.id", "referenz"]),
            ("prozessdaten", &["beginndatum", "ideQualifier", "pruefidentifikator", "vorgangId"]),
            ("tranche", &["trancheId"]),
            ("zaehler_daten", &["referenz.id", "referenz.typ"]),
            ("zuordnung", &["merkmal.code", "merkmal.code_codepflege", "merkmal.codeliste", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55074Interchange = crate::model::Interchange<
    Pid55074MessageStammdaten,
    Pid55074TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55075MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55075: Stammdaten aufgrund einer Änderung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55075TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.postleitzahl, codepflegeCode, geschaeftspartnerId, partnerrolle, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, jahresverbrauchsprognose, mengeneinheit, messlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl_daten: Option<Vec<ObisKennzahlDatenWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_marktlokation: Option<Vec<ObisMarktlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_zaehleinrichtung: Option<Vec<ObisZaehleinrichtungWrapped>>,
    /// Required (Muss). Fields: beginndatum, ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler_daten: Option<Vec<ZaehlerDatenWrapped>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.code_codepflege, merkmal.codeliste, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55075TransaktionStammdaten {
    /// Required entity fields for PID 55075 (Stammdaten aufgrund einer Änderung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.postleitzahl", "codepflegeCode", "geschaeftspartnerId", "partnerrolle", "referenz"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "referenz"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "jahresverbrauchsprognose", "mengeneinheit", "messlokationsId", "referenz"]),
            ("obis_kennzahl_daten", &["produktIdentifikation.id", "referenz"]),
            ("obis_marktlokation", &["produktIdentifikation.id", "referenz"]),
            ("obis_zaehleinrichtung", &["produktIdentifikation.id", "referenz"]),
            ("prozessdaten", &["beginndatum", "ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("tranche", &["trancheId"]),
            ("zaehler_daten", &["referenz.id", "referenz.typ"]),
            ("zuordnung", &["merkmal.code", "merkmal.code_codepflege", "merkmal.codeliste", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55075Interchange = crate::model::Interchange<
    Pid55075MessageStammdaten,
    Pid55075TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55076MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55076: Antwort auf Stammdaten-änderung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55076TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.postleitzahl, codepflegeCode, geschaeftspartnerId, partnerrolle, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, jahresverbrauchsprognose, mengeneinheit, messlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl_daten: Option<Vec<ObisKennzahlDatenWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_marktlokation: Option<Vec<ObisMarktlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_zaehleinrichtung: Option<Vec<ObisZaehleinrichtungWrapped>>,
    /// Required (Muss). Fields: beginndatum, ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler_daten: Option<Vec<ZaehlerDatenWrapped>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.code_codepflege, merkmal.codeliste, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55076TransaktionStammdaten {
    /// Required entity fields for PID 55076 (Antwort auf Stammdaten-änderung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.postleitzahl", "codepflegeCode", "geschaeftspartnerId", "partnerrolle", "referenz"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "referenz"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "jahresverbrauchsprognose", "mengeneinheit", "messlokationsId", "referenz"]),
            ("obis_kennzahl_daten", &["produktIdentifikation.id", "referenz"]),
            ("obis_marktlokation", &["produktIdentifikation.id", "referenz"]),
            ("obis_zaehleinrichtung", &["produktIdentifikation.id", "referenz"]),
            ("prozessdaten", &["beginndatum", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("tranche", &["trancheId"]),
            ("zaehler_daten", &["referenz.id", "referenz.typ"]),
            ("zuordnung", &["merkmal.code", "merkmal.code_codepflege", "merkmal.codeliste", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55076Interchange = crate::model::Interchange<
    Pid55076MessageStammdaten,
    Pid55076TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55077MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55077: Anmeldung erz. MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55077TransaktionStammdaten {
    /// Required (Muss). Fields: text, textReferenz, textbezug
    pub freitext: Option<Freitext>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub produktpaket_daten: Option<Vec<ProduktpaketDaten>>,
    /// Required (Muss). Fields: gueltigAb, ideQualifier, pruefidentifikator, transaktionsgrund, transaktionsgrundDetail, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.code_codepflege, merkmal.codeliste, merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55077TransaktionStammdaten {
    /// Required entity fields for PID 55077 (Anmeldung erz. MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textReferenz", "textbezug"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("produktpaket_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("prozessdaten", &["gueltigAb", "ideQualifier", "pruefidentifikator", "transaktionsgrund", "transaktionsgrundDetail", "vorgangId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
            ("zuordnung", &["merkmal.code", "merkmal.code_codepflege", "merkmal.codeliste", "merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55077Interchange = crate::model::Interchange<
    Pid55077MessageStammdaten,
    Pid55077TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55078MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55078: Bestätigung Anmeldung erz. MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55078TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, jahresverbrauchsprognose, mengeneinheit, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation_daten: Option<Vec<MesslokationDatenWrapped>>,
    /// Required (Muss). Fields: netzlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: gueltigAb, ideQualifier, pruefidentifikator, pruefschrittCode, referenz, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: referenz, steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.eigenschaft_2, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55078TransaktionStammdaten {
    /// Required entity fields for PID 55078 (Bestätigung Anmeldung erz. MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "jahresverbrauchsprognose", "mengeneinheit", "messlokationsId"]),
            ("messlokation_daten", &["referenz.id", "referenz.typ"]),
            ("netzlokation", &["netzlokationsId", "referenz"]),
            ("prozessdaten", &["gueltigAb", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "referenz", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
            ("steuerbare_ressource", &["referenz", "steuerbareRessourceId"]),
            ("technische_ressource", &["technischeRessourceId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.eigenschaft_2", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55078Interchange = crate::model::Interchange<
    Pid55078MessageStammdaten,
    Pid55078TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55080MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55080: Ablehnung Anmeldung erz. MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55080TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    /// Required (Muss). Fields: adresse.hausnummer, adresse.landescode, adresse.ort, adresse.postleitzahl, adresse.strasse, anrede, codelisteCode, codepflegeCode, geschaeftspartnerId, name1, name2, nameZeile3Feld, nameZeile4Feld, partnerrolle, referenz, region, strasseZeile2, strasseZeile4, zusatzinfo
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: datumNaechsteBearbeitung, gueltigAb, ideQualifier, pruefidentifikator, pruefschrittCode, statusZ35, statusZ35Ebdnummer2, statusZ35Transaktionsgrund2, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55080TransaktionStammdaten {
    /// Required entity fields for PID 55080 (Ablehnung Anmeldung erz. MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("geschaeftspartner", &["adresse.hausnummer", "adresse.landescode", "adresse.ort", "adresse.postleitzahl", "adresse.strasse", "anrede", "codelisteCode", "codepflegeCode", "geschaeftspartnerId", "name1", "name2", "nameZeile3Feld", "nameZeile4Feld", "partnerrolle", "referenz", "region", "strasseZeile2", "strasseZeile4", "zusatzinfo"]),
            ("prozessdaten", &["datumNaechsteBearbeitung", "gueltigAb", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "statusZ35", "statusZ35Ebdnummer2", "statusZ35Transaktionsgrund2", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55080Interchange = crate::model::Interchange<
    Pid55080MessageStammdaten,
    Pid55080TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55095MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55095: Antwort auf GDA erz. MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55095TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.postleitzahl, partnerrolle
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: marktlokationsId, messlokationsId, netzlokationsId, referenz, technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub lokationsbuendel_zuordnung: Option<Vec<LokationsbuendelZuordnungWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation_daten: Option<Vec<MarktlokationDatenWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, messlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: netzlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation_daten: Option<Vec<NetzlokationDatenWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, referenz, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource_daten: Option<Vec<SteuerbareRessourceDatenWrapped>>,
    /// Required (Muss). Fields: technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    /// Required (Muss). Fields: referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource_daten: Option<Vec<TechnischeRessourceDatenWrapped>>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler_daten: Option<Vec<ZaehlerDatenWrapped>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.code_codepflege, merkmal.codeliste, merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55095TransaktionStammdaten {
    /// Required entity fields for PID 55095 (Antwort auf GDA erz. MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.postleitzahl", "partnerrolle"]),
            ("lokationsbuendel_zuordnung", &["marktlokationsId", "messlokationsId", "netzlokationsId", "referenz", "technischeRessourceId"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("marktlokation_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ"]),
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "messlokationsId", "referenz"]),
            ("netzlokation", &["netzlokationsId"]),
            ("netzlokation_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz", "referenz.id", "referenz.typ"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "referenz", "transaktionsgrund", "vorgangId"]),
            ("steuerbare_ressource", &["steuerbareRessourceId"]),
            ("steuerbare_ressource_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ"]),
            ("technische_ressource", &["technischeRessourceId"]),
            ("technische_ressource_daten", &["referenz"]),
            ("tranche", &["trancheId"]),
            ("zaehler_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.code_codepflege", "merkmal.codeliste", "merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55095Interchange = crate::model::Interchange<
    Pid55095MessageStammdaten,
    Pid55095TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55109MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55109: Änderung Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55109TransaktionStammdaten {
    /// Required (Muss). Fields: anredeCode, nachname, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub ansprechpartner: Option<Vec<Ansprechpartner>>,
    /// Required (Muss). Fields: privilegierungsgrund, verringerungUmlage, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub enfg_daten: Option<Vec<EnfgDaten>>,
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.strasse, anredeCode, name1, region, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: landDerFoerderung, marktlokationsId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, transaktionsgrundErgaenzung, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55109TransaktionStammdaten {
    /// Required entity fields for PID 55109 (Änderung Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("ansprechpartner", &["anredeCode", "nachname", "zeitscheibe.referenz"]),
            ("enfg_daten", &["privilegierungsgrund", "verringerungUmlage", "zeitscheibe.referenz"]),
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.strasse", "anredeCode", "name1", "region", "zeitscheibe.referenz"]),
            ("marktlokation", &["landDerFoerderung", "marktlokationsId", "zeitscheibe.referenz"]),
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "transaktionsgrundErgaenzung", "vorgangId"]),
        ]
    }
}

pub type Pid55109Interchange = crate::model::Interchange<
    Pid55109MessageStammdaten,
    Pid55109TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55110MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55110: Änderung Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55110TransaktionStammdaten {
    /// Required (Muss). Fields: anredeCode, nachname, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub ansprechpartner: Option<Vec<Ansprechpartner>>,
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.strasse, anredeCode, name1, region, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55110TransaktionStammdaten {
    /// Required entity fields for PID 55110 (Änderung Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("ansprechpartner", &["anredeCode", "nachname", "zeitscheibe.referenz"]),
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.strasse", "anredeCode", "name1", "region", "zeitscheibe.referenz"]),
            ("marktlokation", &["marktlokationsId"]),
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55110Interchange = crate::model::Interchange<
    Pid55110MessageStammdaten,
    Pid55110TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55126MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55126: Abr.-Daten BK-Abr. verb. Malo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55126TransaktionStammdaten {
    /// Required (Muss). Fields: abrechnungsmethode, bilanzierungsgebiet, bilanzkreis, codelisteCode, codepflegeCode, marktlokationsId, marktlokationsIdRef, regelzone, zeitreihenCode, zeitreihentyp, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: standardlastprofil, standardlastprofilVerfahren, tagesparameterProfil, tagesparameterVerfahren, z08ZeitscheibeRef, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub profil_daten: Option<Vec<ProfilDaten>>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55126TransaktionStammdaten {
    /// Required entity fields for PID 55126 (Abr.-Daten BK-Abr. verb. Malo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["abrechnungsmethode", "bilanzierungsgebiet", "bilanzkreis", "codelisteCode", "codepflegeCode", "marktlokationsId", "marktlokationsIdRef", "regelzone", "zeitreihenCode", "zeitreihentyp", "zeitscheibe.referenz"]),
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("profil_daten", &["standardlastprofil", "standardlastprofilVerfahren", "tagesparameterProfil", "tagesparameterVerfahren", "z08ZeitscheibeRef", "zeitscheibe.referenz"]),
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55126Interchange = crate::model::Interchange<
    Pid55126MessageStammdaten,
    Pid55126TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55136MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55136: Rückmeldung/Anfrage Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55136TransaktionStammdaten {
    /// Required (Muss). Fields: anredeCode, land, nachname, ort, partnerrolle, strasse, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55136TransaktionStammdaten {
    /// Required entity fields for PID 55136 (Rückmeldung/Anfrage Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["anredeCode", "land", "nachname", "ort", "partnerrolle", "strasse", "zeitscheibe.referenz"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55136Interchange = crate::model::Interchange<
    Pid55136MessageStammdaten,
    Pid55136TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55137MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55137: Rückmeldung/Anfrage Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55137TransaktionStammdaten {
    /// Required (Muss). Fields: privilegierungsgrund, privilegierungsgrund2, verringerungUmlage
    pub enfg_daten: Option<EnfgDaten>,
    /// Required (Muss). Fields: anredeCode, kundennummerBeimLf, land, nachname, ort, partnerrolle, strasse, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, landDerFoerderung, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55137TransaktionStammdaten {
    /// Required entity fields for PID 55137 (Rückmeldung/Anfrage Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("enfg_daten", &["privilegierungsgrund", "privilegierungsgrund2", "verringerungUmlage"]),
            ("geschaeftspartner", &["anredeCode", "kundennummerBeimLf", "land", "nachname", "ort", "partnerrolle", "strasse", "zeitscheibe.referenz"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "landDerFoerderung", "marktlokationsId"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55137Interchange = crate::model::Interchange<
    Pid55137MessageStammdaten,
    Pid55137TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55156MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55156: Rückmeldung/Anfrage Abr.-Daten BK-Abr. verb. MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55156TransaktionStammdaten {
    /// Required (Muss). Fields: abrechnungsmethode, bilanzierungsgebiet, bilanzkreis, codelisteCode, codepflegeCode, marktlokationsId, regelzone, zeitreihenCode, zeitreihentyp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: standardlastprofil, standardlastprofilVerfahren, tagesparameterProfil, tagesparameterVerfahren
    pub profil_daten: Option<ProfilDaten>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, referenz, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55156TransaktionStammdaten {
    /// Required entity fields for PID 55156 (Rückmeldung/Anfrage Abr.-Daten BK-Abr. verb. MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["abrechnungsmethode", "bilanzierungsgebiet", "bilanzkreis", "codelisteCode", "codepflegeCode", "marktlokationsId", "regelzone", "zeitreihenCode", "zeitreihentyp"]),
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("profil_daten", &["standardlastprofil", "standardlastprofilVerfahren", "tagesparameterProfil", "tagesparameterVerfahren"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "referenz", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55156Interchange = crate::model::Interchange<
    Pid55156MessageStammdaten,
    Pid55156TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55168MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55168: Verpflicht-ungsanfrage / Aufforderung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55168TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.postleitzahl, anredeCode, codelisteCode, codepflegeCode, geschaeftspartnerId, name1, partnerrolle, referenz, region, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub lokationsbuendel_daten: Option<Vec<LokationsbuendelDatenWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, referenz, ruhendeMarktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub mengen_daten: Option<Vec<MengenDaten>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub mengen_daten_erw: Option<Vec<MengenDatenErw>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, jahresverbrauchsprognose, mengeneinheit, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation_daten: Option<Vec<MesslokationDatenWrapped>>,
    /// Required (Muss). Fields: netzlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl: Option<Vec<ObisKennzahlWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_marktlokation: Option<Vec<ObisMarktlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_zaehleinrichtung: Option<Vec<ObisZaehleinrichtungWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub produktpaket_daten: Option<Vec<ProduktpaketDaten>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub profil_daten: Option<Vec<ProfilDaten>>,
    /// Required (Muss). Fields: datumZ50, geplanterLieferbeginn, ideQualifier, pruefidentifikator, referenz, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub referenzprofil: Option<Vec<Referenzprofil>>,
    /// Required (Muss). Fields: steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource_daten: Option<Vec<SteuerbareRessourceDatenWrapped>>,
    /// Required (Muss). Fields: referenz, technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler_daten: Option<Vec<ZaehlerDatenWrapped>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.code_codepflege, merkmal.codeliste, merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55168TransaktionStammdaten {
    /// Required entity fields for PID 55168 (Verpflicht-ungsanfrage / Aufforderung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.postleitzahl", "anredeCode", "codelisteCode", "codepflegeCode", "geschaeftspartnerId", "name1", "partnerrolle", "referenz", "region", "zeitscheibe.referenz"]),
            ("lokationsbuendel_daten", &["referenz"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "referenz", "ruhendeMarktlokationsId"]),
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("mengen_daten", &["produktIdentifikation.id", "referenz"]),
            ("mengen_daten_erw", &["produktIdentifikation.id", "referenz"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "jahresverbrauchsprognose", "mengeneinheit", "messlokationsId"]),
            ("messlokation_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ"]),
            ("netzlokation", &["netzlokationsId", "referenz"]),
            ("obis_kennzahl", &["produktIdentifikation.id", "referenz"]),
            ("obis_marktlokation", &["produktIdentifikation.id", "referenz"]),
            ("obis_zaehleinrichtung", &["produktIdentifikation.id", "referenz"]),
            ("produktpaket_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ", "zeitscheibe.referenz"]),
            ("profil_daten", &["referenz.id", "referenz.typ"]),
            ("prozessdaten", &["datumZ50", "geplanterLieferbeginn", "ideQualifier", "pruefidentifikator", "referenz", "transaktionsgrund", "vorgangId"]),
            ("referenzprofil", &["referenz"]),
            ("steuerbare_ressource", &["steuerbareRessourceId"]),
            ("steuerbare_ressource_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ"]),
            ("technische_ressource", &["referenz", "technischeRessourceId"]),
            ("tranche", &["trancheId"]),
            ("zaehler_daten", &["referenz.id", "referenz.typ"]),
            ("zuordnung", &["merkmal.code", "merkmal.code_codepflege", "merkmal.codeliste", "merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55168Interchange = crate::model::Interchange<
    Pid55168MessageStammdaten,
    Pid55168TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55169MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55169: Bestätigung Verpflicht-ungsanfrage
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55169TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.postleitzahl, anredeCode, codelisteCode, codepflegeCode, geschaeftspartnerId, name1, partnerrolle, referenz, region, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub lokationsbuendel_daten: Option<Vec<LokationsbuendelDatenWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub mengen_daten: Option<Vec<MengenDaten>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub mengen_daten_erw: Option<Vec<MengenDatenErw>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, jahresverbrauchsprognose, mengeneinheit, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation_daten: Option<Vec<MesslokationDatenWrapped>>,
    /// Required (Muss). Fields: netzlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl: Option<Vec<ObisKennzahlWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_marktlokation: Option<Vec<ObisMarktlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_zaehleinrichtung: Option<Vec<ObisZaehleinrichtungWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub produktpaket_daten: Option<Vec<ProduktpaketDaten>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub profil_daten: Option<Vec<ProfilDaten>>,
    /// Required (Muss). Fields: datumZ50, geplanterLieferbeginn, ideQualifier, pruefidentifikator, pruefschrittCode, referenz, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub referenzprofil: Option<Vec<Referenzprofil>>,
    /// Required (Muss). Fields: steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource_daten: Option<Vec<SteuerbareRessourceDatenWrapped>>,
    /// Required (Muss). Fields: referenz, technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler_daten: Option<Vec<ZaehlerDatenWrapped>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.code_codepflege, merkmal.codeliste, merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55169TransaktionStammdaten {
    /// Required entity fields for PID 55169 (Bestätigung Verpflicht-ungsanfrage).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.postleitzahl", "anredeCode", "codelisteCode", "codepflegeCode", "geschaeftspartnerId", "name1", "partnerrolle", "referenz", "region", "zeitscheibe.referenz"]),
            ("lokationsbuendel_daten", &["referenz"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "referenz"]),
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("mengen_daten", &["produktIdentifikation.id", "referenz"]),
            ("mengen_daten_erw", &["produktIdentifikation.id", "referenz"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "jahresverbrauchsprognose", "mengeneinheit", "messlokationsId"]),
            ("messlokation_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ"]),
            ("netzlokation", &["netzlokationsId", "referenz"]),
            ("obis_kennzahl", &["produktIdentifikation.id", "referenz"]),
            ("obis_marktlokation", &["produktIdentifikation.id", "referenz"]),
            ("obis_zaehleinrichtung", &["produktIdentifikation.id", "referenz"]),
            ("produktpaket_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ", "zeitscheibe.referenz"]),
            ("profil_daten", &["referenz.id", "referenz.typ"]),
            ("prozessdaten", &["datumZ50", "geplanterLieferbeginn", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "referenz", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("referenzprofil", &["referenz"]),
            ("steuerbare_ressource", &["steuerbareRessourceId"]),
            ("steuerbare_ressource_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ"]),
            ("technische_ressource", &["referenz", "technischeRessourceId"]),
            ("tranche", &["trancheId"]),
            ("zaehler_daten", &["referenz.id", "referenz.typ"]),
            ("zuordnung", &["merkmal.code", "merkmal.code_codepflege", "merkmal.codeliste", "merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55169Interchange = crate::model::Interchange<
    Pid55169MessageStammdaten,
    Pid55169TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55170MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55170: Ablehnung Verpflicht-ungsanfrage
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55170TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55170TransaktionStammdaten {
    /// Required entity fields for PID 55170 (Ablehnung Verpflicht-ungsanfrage).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["codelisteCode", "codepflegeCode", "messlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55170Interchange = crate::model::Interchange<
    Pid55170MessageStammdaten,
    Pid55170TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55173MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55173: Änderung der Lokationsbündelstruktur
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55173TransaktionStammdaten {
    /// Required (Muss). Fields: referenz, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub lokationsbuendel_daten: Option<Vec<LokationsbuendelDatenWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, lokationZeitraumId, marktlokationsId, ruhendeMarktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, lokationZeitraumId, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: lokationZeitraumId, netzlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: lokationZeitraumId, steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: lokationZeitraumId, technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55173TransaktionStammdaten {
    /// Required entity fields for PID 55173 (Änderung der Lokationsbündelstruktur).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("lokationsbuendel_daten", &["referenz", "zeitscheibe.referenz"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "lokationZeitraumId", "marktlokationsId", "ruhendeMarktlokationsId"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "lokationZeitraumId", "messlokationsId"]),
            ("netzlokation", &["lokationZeitraumId", "netzlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("steuerbare_ressource", &["lokationZeitraumId", "steuerbareRessourceId"]),
            ("technische_ressource", &["lokationZeitraumId", "technischeRessourceId"]),
        ]
    }
}

pub type Pid55173Interchange = crate::model::Interchange<
    Pid55173MessageStammdaten,
    Pid55173TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55175MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55175: Änderung der Lokationsbündelstruktur
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55175TransaktionStammdaten {
    /// Required (Muss). Fields: lokationsbuendelId, objektcode, vorgelagerteLokation, vorgelagerteLokation2, zeitscheibe.referenz, zugeordneteMarktlokation, zugeordneteNetzlokation, zugeordneteSteuerbareRessource, zugeordneteTechnischeRessource
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub lokationsbuendel_daten: Option<Vec<LokationsbuendelDatenWrapped>>,
    /// Required (Muss). Fields: lokationsbuendelStrukturId, referenzQualifier, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub lokationsbuendel_struktur: Option<Vec<LokationsbuendelStruktur>>,
    /// Required (Muss). Fields: lokationZeitraumId, marktlokationsId, ruhendeMarktlokationsId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: messlokationsId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: netzlokationsId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: steuerbareRessourceId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: technischeRessourceId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    /// Required (Muss). Fields: identifikation, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55175TransaktionStammdaten {
    /// Required entity fields for PID 55175 (Änderung der Lokationsbündelstruktur).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("lokationsbuendel_daten", &["lokationsbuendelId", "objektcode", "vorgelagerteLokation", "vorgelagerteLokation2", "zeitscheibe.referenz", "zugeordneteMarktlokation", "zugeordneteNetzlokation", "zugeordneteSteuerbareRessource", "zugeordneteTechnischeRessource"]),
            ("lokationsbuendel_struktur", &["lokationsbuendelStrukturId", "referenzQualifier", "zeitscheibe.referenz"]),
            ("marktlokation", &["lokationZeitraumId", "marktlokationsId", "ruhendeMarktlokationsId", "zeitscheibe.referenz"]),
            ("messlokation", &["messlokationsId", "zeitscheibe.referenz"]),
            ("netzlokation", &["netzlokationsId", "zeitscheibe.referenz"]),
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("steuerbare_ressource", &["steuerbareRessourceId", "zeitscheibe.referenz"]),
            ("technische_ressource", &["technischeRessourceId", "zeitscheibe.referenz"]),
            ("tranche", &["identifikation", "zeitscheibe.referenz"]),
        ]
    }
}

pub type Pid55175Interchange = crate::model::Interchange<
    Pid55175MessageStammdaten,
    Pid55175TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55177MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55177: Rückmeldung/Anfrage Lokationsbündelstruktur
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55177TransaktionStammdaten {
    /// Required (Muss). Fields: lokationZeitraumId, marktlokationsId, ruhendeMarktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: datenqualitaet, referenz, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation_daten: Option<Vec<MarktlokationDatenWrapped>>,
    /// Required (Muss). Fields: lokationZeitraumId, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: lokationZeitraumId, netzlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: lokationZeitraumId, steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: lokationZeitraumId, technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55177TransaktionStammdaten {
    /// Required entity fields for PID 55177 (Rückmeldung/Anfrage Lokationsbündelstruktur).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["lokationZeitraumId", "marktlokationsId", "ruhendeMarktlokationsId"]),
            ("marktlokation_daten", &["datenqualitaet", "referenz", "zeitscheibe.referenz"]),
            ("messlokation", &["lokationZeitraumId", "messlokationsId"]),
            ("netzlokation", &["lokationZeitraumId", "netzlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("steuerbare_ressource", &["lokationZeitraumId", "steuerbareRessourceId"]),
            ("technische_ressource", &["lokationZeitraumId", "technischeRessourceId"]),
        ]
    }
}

pub type Pid55177Interchange = crate::model::Interchange<
    Pid55177MessageStammdaten,
    Pid55177TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55180MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55180: Rückmeldung/Anfrage Lokationsbündelstruktur
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55180TransaktionStammdaten {
    /// Required (Muss). Fields: lokationZeitraumId, marktlokationsId, ruhendeMarktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: lokationZeitraumId, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: lokationZeitraumId, netzlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, pruefschrittCode2, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: lokationZeitraumId, steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: lokationZeitraumId, technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    pub tranche: Option<Tranche>,
}

impl Pid55180TransaktionStammdaten {
    /// Required entity fields for PID 55180 (Rückmeldung/Anfrage Lokationsbündelstruktur).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["lokationZeitraumId", "marktlokationsId", "ruhendeMarktlokationsId"]),
            ("messlokation", &["lokationZeitraumId", "messlokationsId"]),
            ("netzlokation", &["lokationZeitraumId", "netzlokationsId"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "pruefschrittCode2", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("steuerbare_ressource", &["lokationZeitraumId", "steuerbareRessourceId"]),
            ("technische_ressource", &["lokationZeitraumId", "technischeRessourceId"]),
        ]
    }
}

pub type Pid55180Interchange = crate::model::Interchange<
    Pid55180MessageStammdaten,
    Pid55180TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55194MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55194: Antwort auf GDA (Strom an Gas)
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55194TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.postleitzahl, anrede, codelisteCode, codepflegeCode, geschaeftspartnerId, name1, name2, nameZeile3Feld, nameZeile4Feld, partnerrolle, referenz, region
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, referenz, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss).
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler: Option<Vec<ZaehlerWrapped>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.eigenschaft_2, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55194TransaktionStammdaten {
    /// Required entity fields for PID 55194 (Antwort auf GDA (Strom an Gas)).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.postleitzahl", "anrede", "codelisteCode", "codepflegeCode", "geschaeftspartnerId", "name1", "name2", "nameZeile3Feld", "nameZeile4Feld", "partnerrolle", "referenz", "region"]),
            ("messlokation", &["referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "referenz", "transaktionsgrund", "vorgangId"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.eigenschaft_2", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55194Interchange = crate::model::Interchange<
    Pid55194MessageStammdaten,
    Pid55194TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55195MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55195: Bilanzierungs-gebiets-clearing-liste
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55195TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl_daten: Option<Vec<ObisKennzahlDatenWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_marktlokation: Option<Vec<ObisMarktlokationWrapped>>,
    /// Required (Muss). Fields: referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub profil: Option<Vec<Profil>>,
    /// Required (Muss). Fields: aenderungBis, aenderungVon, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: referenz.id, referenz.typ, zeitscheibe.referenz
    pub summenzeitreihen_daten: Option<SummenzeitreihenDaten>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche_daten: Option<Vec<TrancheDaten>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55195TransaktionStammdaten {
    /// Required entity fields for PID 55195 (Bilanzierungs-gebiets-clearing-liste).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "referenz"]),
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("messlokation", &["mabisZaehlpunktId"]),
            ("obis_kennzahl_daten", &["produktIdentifikation.id", "referenz"]),
            ("obis_marktlokation", &["produktIdentifikation.id", "referenz"]),
            ("profil", &["referenz"]),
            ("prozessdaten", &["aenderungBis", "aenderungVon", "ideQualifier", "pruefidentifikator", "vorgangId"]),
            ("summenzeitreihen_daten", &["referenz.id", "referenz.typ", "zeitscheibe.referenz"]),
            ("tranche", &["trancheId"]),
            ("tranche_daten", &["referenz.id", "referenz.typ"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55195Interchange = crate::model::Interchange<
    Pid55195MessageStammdaten,
    Pid55195TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55196MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55196: Antwort auf Bilanzierungs-gebiets-clearing-liste
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55196TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl_daten: Option<Vec<ObisKennzahlDatenWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_marktlokation: Option<Vec<ObisMarktlokationWrapped>>,
    /// Required (Muss). Fields: referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub profil: Option<Vec<Profil>>,
    /// Required (Muss). Fields: aenderungBis, aenderungVon, datumZ22, ebdNummer, ebdNummer2, ideQualifier, pruefidentifikator, pruefschrittCode, pruefschrittCode2, referenz, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: referenz
    pub seq_daten_z29: Option<SeqDatenZ29>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub seq_daten_z29_mengen: Option<SeqDatenZ29Mengen>,
    /// Required (Muss). Fields: produktIdentifikation.id
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub seq_daten_z30: Option<Vec<SeqDatenZ30>>,
    /// Optional.
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub seq_daten_z31: Option<Vec<SeqDatenZ31>>,
    /// Required (Muss). Fields: produktIdentifikation.id
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub seq_daten_z32: Option<Vec<SeqDatenZ32>>,
    /// Optional.
    pub seq_daten_z33: Option<SeqDatenZ33>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: referenz.id, referenz.typ, zeitscheibe.referenz
    pub summenzeitreihen_daten: Option<SummenzeitreihenDaten>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche_daten: Option<Vec<TrancheDaten>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55196TransaktionStammdaten {
    /// Required entity fields for PID 55196 (Antwort auf Bilanzierungs-gebiets-clearing-liste).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "referenz"]),
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("messlokation", &["mabisZaehlpunktId"]),
            ("obis_kennzahl_daten", &["produktIdentifikation.id", "referenz"]),
            ("obis_marktlokation", &["produktIdentifikation.id", "referenz"]),
            ("profil", &["referenz"]),
            ("prozessdaten", &["aenderungBis", "aenderungVon", "datumZ22", "ebdNummer", "ebdNummer2", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "pruefschrittCode2", "referenz", "transaktionsnummer", "vorgangId"]),
            ("seq_daten_z29", &["referenz"]),
            ("seq_daten_z29_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("seq_daten_z30", &["produktIdentifikation.id"]),
            ("seq_daten_z32", &["produktIdentifikation.id"]),
            ("summenzeitreihen_daten", &["referenz.id", "referenz.typ", "zeitscheibe.referenz"]),
            ("tranche", &["trancheId"]),
            ("tranche_daten", &["referenz.id", "referenz.typ"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55196Interchange = crate::model::Interchange<
    Pid55196MessageStammdaten,
    Pid55196TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55197MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55197: Aktivierung ZP tägliche AAÜZ
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55197TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungVon, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub redispatch_daten: Option<Vec<RedispatchDaten>>,
    /// Required (Muss). Fields: produktIdentifikation.id
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub redispatch_daten_erw: Option<Vec<RedispatchDatenErw>>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55197TransaktionStammdaten {
    /// Required entity fields for PID 55197 (Aktivierung ZP tägliche AAÜZ).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungVon", "ideQualifier", "pruefidentifikator", "vorgangId"]),
            ("redispatch_daten", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
            ("redispatch_daten_erw", &["produktIdentifikation.id"]),
        ]
    }
}

pub type Pid55197Interchange = crate::model::Interchange<
    Pid55197MessageStammdaten,
    Pid55197TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55198MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55198: Deaktivierung tägliche AAÜZ
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55198TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungBis, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55198TransaktionStammdaten {
    /// Required entity fields for PID 55198 (Deaktivierung tägliche AAÜZ).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungBis", "ideQualifier", "pruefidentifikator", "vorgangId"]),
        ]
    }
}

pub type Pid55198Interchange = crate::model::Interchange<
    Pid55198MessageStammdaten,
    Pid55198TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55199MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55199: Aktivierung ZP LF-AASZR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55199TransaktionStammdaten {
    /// Required (Muss). Fields: produktIdentifikation.id
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub clearing_daten: Option<Vec<ClearingDaten>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId, merkmal.code, merkmal.klasse, merkmal.qualifier
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungVon, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55199TransaktionStammdaten {
    /// Required entity fields for PID 55199 (Aktivierung ZP LF-AASZR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("clearing_daten", &["produktIdentifikation.id"]),
            ("messlokation", &["mabisZaehlpunktId", "merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
            ("prozessdaten", &["aenderungVon", "ideQualifier", "pruefidentifikator", "vorgangId"]),
        ]
    }
}

pub type Pid55199Interchange = crate::model::Interchange<
    Pid55199MessageStammdaten,
    Pid55199TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55200MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55200: Deaktivierung ZP LF-AASZR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55200TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungBis, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55200TransaktionStammdaten {
    /// Required entity fields for PID 55200 (Deaktivierung ZP LF-AASZR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungBis", "ideQualifier", "pruefidentifikator", "vorgangId"]),
        ]
    }
}

pub type Pid55200Interchange = crate::model::Interchange<
    Pid55200MessageStammdaten,
    Pid55200TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55201MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55201: LF-AACL
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55201TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, jahresverbrauchsprognose, marktlokationsId, mengeneinheit, merkmal.code, merkmal.klasse, merkmal.qualifier, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: jahresverbrauchsprognose, mabisZaehlpunktId, mengeneinheit
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: referenz.id, referenz.typ, zeitscheibe.referenz
    pub summenzeitreihen_daten: Option<SummenzeitreihenDaten>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche_daten: Option<Vec<TrancheDaten>>,
}

impl Pid55201TransaktionStammdaten {
    /// Required entity fields for PID 55201 (LF-AACL).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "jahresverbrauchsprognose", "marktlokationsId", "mengeneinheit", "merkmal.code", "merkmal.klasse", "merkmal.qualifier", "referenz"]),
            ("messlokation", &["jahresverbrauchsprognose", "mabisZaehlpunktId", "mengeneinheit"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "vorgangId"]),
            ("summenzeitreihen_daten", &["referenz.id", "referenz.typ", "zeitscheibe.referenz"]),
            ("tranche", &["trancheId"]),
            ("tranche_daten", &["referenz.id", "referenz.typ"]),
        ]
    }
}

pub type Pid55201Interchange = crate::model::Interchange<
    Pid55201MessageStammdaten,
    Pid55201TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55202MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55202: Korrekturliste LF-AACL
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55202TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, jahresverbrauchsprognose, marktlokationsId, mengeneinheit, merkmal.code, merkmal.klasse, merkmal.qualifier, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: jahresverbrauchsprognose, mabisZaehlpunktId, mengeneinheit
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ebdNummer, ebdNummer2, ideQualifier, pruefidentifikator, pruefschrittCode, pruefschrittCode2, transaktionsnummer, transaktionsnummer2, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: referenz.id, referenz.typ, zeitscheibe.referenz
    pub summenzeitreihen_daten: Option<SummenzeitreihenDaten>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche_daten: Option<Vec<TrancheDaten>>,
}

impl Pid55202TransaktionStammdaten {
    /// Required entity fields for PID 55202 (Korrekturliste LF-AACL).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "jahresverbrauchsprognose", "marktlokationsId", "mengeneinheit", "merkmal.code", "merkmal.klasse", "merkmal.qualifier", "referenz"]),
            ("messlokation", &["jahresverbrauchsprognose", "mabisZaehlpunktId", "mengeneinheit"]),
            ("prozessdaten", &["ebdNummer", "ebdNummer2", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "pruefschrittCode2", "transaktionsnummer", "transaktionsnummer2", "vorgangId"]),
            ("summenzeitreihen_daten", &["referenz.id", "referenz.typ", "zeitscheibe.referenz"]),
            ("tranche", &["trancheId"]),
            ("tranche_daten", &["referenz.id", "referenz.typ"]),
        ]
    }
}

pub type Pid55202Interchange = crate::model::Interchange<
    Pid55202MessageStammdaten,
    Pid55202TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55203MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55203: Aktivierung ZP monatliche AAÜZ
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55203TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungVon, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub redispatch_daten: Option<Vec<RedispatchDaten>>,
    /// Required (Muss). Fields: produktIdentifikation.id
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub redispatch_daten_erw: Option<Vec<RedispatchDatenErw>>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55203TransaktionStammdaten {
    /// Required entity fields for PID 55203 (Aktivierung ZP monatliche AAÜZ).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungVon", "ideQualifier", "pruefidentifikator", "vorgangId"]),
            ("redispatch_daten", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
            ("redispatch_daten_erw", &["produktIdentifikation.id"]),
        ]
    }
}

pub type Pid55203Interchange = crate::model::Interchange<
    Pid55203MessageStammdaten,
    Pid55203TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55204MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55204: Antwort auf Aktivierung ZP
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55204TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungVon, ebdNummer, ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55204TransaktionStammdaten {
    /// Required entity fields for PID 55204 (Antwort auf Aktivierung ZP).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungVon", "ebdNummer", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55204Interchange = crate::model::Interchange<
    Pid55204MessageStammdaten,
    Pid55204TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55205MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55205: Weiterleitung Aktivierung ZP
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55205TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungVon, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub redispatch_daten: Option<Vec<RedispatchDaten>>,
    /// Required (Muss). Fields: produktIdentifikation.id
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub redispatch_daten_erw: Option<Vec<RedispatchDatenErw>>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55205TransaktionStammdaten {
    /// Required entity fields for PID 55205 (Weiterleitung Aktivierung ZP).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungVon", "ideQualifier", "pruefidentifikator", "vorgangId"]),
            ("redispatch_daten", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
            ("redispatch_daten_erw", &["produktIdentifikation.id"]),
        ]
    }
}

pub type Pid55205Interchange = crate::model::Interchange<
    Pid55205MessageStammdaten,
    Pid55205TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55206MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55206: Deaktivierung ZP monatliche AAÜZ
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55206TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungBis, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55206TransaktionStammdaten {
    /// Required entity fields for PID 55206 (Deaktivierung ZP monatliche AAÜZ).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungBis", "ideQualifier", "pruefidentifikator", "vorgangId"]),
        ]
    }
}

pub type Pid55206Interchange = crate::model::Interchange<
    Pid55206MessageStammdaten,
    Pid55206TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55207MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55207: Antwort auf Deaktivierung ZP
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55207TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungBis, ebdNummer, ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55207TransaktionStammdaten {
    /// Required entity fields for PID 55207 (Antwort auf Deaktivierung ZP).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungBis", "ebdNummer", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55207Interchange = crate::model::Interchange<
    Pid55207MessageStammdaten,
    Pid55207TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55208MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55208: Weiterleitung Deaktivierung ZP
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55208TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungBis, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55208TransaktionStammdaten {
    /// Required entity fields for PID 55208 (Weiterleitung Deaktivierung ZP).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungBis", "ideQualifier", "pruefidentifikator", "vorgangId"]),
        ]
    }
}

pub type Pid55208Interchange = crate::model::Interchange<
    Pid55208MessageStammdaten,
    Pid55208TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55209MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55209: Aktivierung ZP monatliche AAÜZ
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55209TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungVon, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub redispatch_daten: Option<Vec<RedispatchDaten>>,
    /// Required (Muss). Fields: produktIdentifikation.id
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub redispatch_daten_erw: Option<Vec<RedispatchDatenErw>>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55209TransaktionStammdaten {
    /// Required entity fields for PID 55209 (Aktivierung ZP monatliche AAÜZ).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungVon", "ideQualifier", "pruefidentifikator", "vorgangId"]),
            ("redispatch_daten", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
            ("redispatch_daten_erw", &["produktIdentifikation.id"]),
        ]
    }
}

pub type Pid55209Interchange = crate::model::Interchange<
    Pid55209MessageStammdaten,
    Pid55209TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55210MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55210: Antwort auf Aktivierung ZP
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55210TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungVon, ebdNummer, ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55210TransaktionStammdaten {
    /// Required entity fields for PID 55210 (Antwort auf Aktivierung ZP).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungVon", "ebdNummer", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55210Interchange = crate::model::Interchange<
    Pid55210MessageStammdaten,
    Pid55210TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55211MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55211: Weiterleitung Aktivierung ZP
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55211TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungVon, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub redispatch_daten: Option<Vec<RedispatchDaten>>,
    /// Required (Muss). Fields: produktIdentifikation.id
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub redispatch_daten_erw: Option<Vec<RedispatchDatenErw>>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55211TransaktionStammdaten {
    /// Required entity fields for PID 55211 (Weiterleitung Aktivierung ZP).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungVon", "ideQualifier", "pruefidentifikator", "vorgangId"]),
            ("redispatch_daten", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
            ("redispatch_daten_erw", &["produktIdentifikation.id"]),
        ]
    }
}

pub type Pid55211Interchange = crate::model::Interchange<
    Pid55211MessageStammdaten,
    Pid55211TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55212MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55212: Deaktivierung ZP monatliche AAÜZ
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55212TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungBis, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55212TransaktionStammdaten {
    /// Required entity fields for PID 55212 (Deaktivierung ZP monatliche AAÜZ).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungBis", "ideQualifier", "pruefidentifikator", "vorgangId"]),
        ]
    }
}

pub type Pid55212Interchange = crate::model::Interchange<
    Pid55212MessageStammdaten,
    Pid55212TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55213MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55213: Antwort auf Deaktivierung ZP
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55213TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungBis, ebdNummer, ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55213TransaktionStammdaten {
    /// Required entity fields for PID 55213 (Antwort auf Deaktivierung ZP).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungBis", "ebdNummer", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55213Interchange = crate::model::Interchange<
    Pid55213MessageStammdaten,
    Pid55213TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55214MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55214: Weiterleitung Deaktivierung ZP
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55214TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungBis, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55214TransaktionStammdaten {
    /// Required entity fields for PID 55214 (Weiterleitung Deaktivierung ZP).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungBis", "ideQualifier", "pruefidentifikator", "vorgangId"]),
        ]
    }
}

pub type Pid55214Interchange = crate::model::Interchange<
    Pid55214MessageStammdaten,
    Pid55214TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55218MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55218: Abr.-Daten NNA
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55218TransaktionStammdaten {
    /// Required (Muss). Fields: naechsteNetznutzungsabrechnung, nnaFormat, nnaZeitraum, nnaZeitraumFormat, terminNetznutzungsabrechnung, terminNnaFormat, termindatenReferenz
    pub abrechnungsdaten: Option<AbrechnungsdatenWrapped>,
    /// Required (Muss). Fields: codelisteCode, grundlageLieferscheinpruefung, marktlokationsId, netznutzungsvertrag, verbrauchsaufteilung, zahlungNetznutzung
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: merkmal.beschreibung, merkmal.code, merkmal.qualifier, merkmal.typ, zugeordneterMp
    pub netznutzungsabrechnungsdaten: Option<NetznutzungsabrechnungsdatenWrapped>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub netznutzungsabrechnungsdaten_mengen: Option<NetznutzungsabrechnungsdatenMengenWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55218TransaktionStammdaten {
    /// Required entity fields for PID 55218 (Abr.-Daten NNA).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("abrechnungsdaten", &["naechsteNetznutzungsabrechnung", "nnaFormat", "nnaZeitraum", "nnaZeitraumFormat", "terminNetznutzungsabrechnung", "terminNnaFormat", "termindatenReferenz"]),
            ("marktlokation", &["codelisteCode", "grundlageLieferscheinpruefung", "marktlokationsId", "netznutzungsvertrag", "verbrauchsaufteilung", "zahlungNetznutzung"]),
            ("netznutzungsabrechnungsdaten", &["merkmal.beschreibung", "merkmal.code", "merkmal.qualifier", "merkmal.typ", "zugeordneterMp"]),
            ("netznutzungsabrechnungsdaten_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55218Interchange = crate::model::Interchange<
    Pid55218MessageStammdaten,
    Pid55218TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55220MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55220: Rückmeldung/Anfrage Abr.-Daten NNA
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55220TransaktionStammdaten {
    pub abrechnungsdaten: Option<AbrechnungsdatenWrapped>,
    /// Required (Muss). Fields: marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55220TransaktionStammdaten {
    /// Required entity fields for PID 55220 (Rückmeldung/Anfrage Abr.-Daten NNA).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["marktlokationsId"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55220Interchange = crate::model::Interchange<
    Pid55220MessageStammdaten,
    Pid55220TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55223MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55223: DZÜ Liste
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55223TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: mabisZaehlpunktId, referenz
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Optional.
    pub zeitreihen_daten47: Option<ZeitreihenDaten47>,
    /// Required (Muss). Fields: datum.format, datum.wert, menge, mengenQualifier, mengeneinheit
    pub zeitreihen_daten47_mengen: Option<ZeitreihenDaten47Mengen>,
    /// Required (Muss). Fields: referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zeitreihen_daten48: Option<Vec<ZeitreihenDaten48>>,
    /// Required (Muss). Fields: datum.format, datum.wert, menge, mengenQualifier, mengeneinheit
    pub zeitreihen_daten48_mengen: Option<ZeitreihenDaten48Mengen>,
    /// Required (Muss). Fields: referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zeitreihen_daten49: Option<Vec<ZeitreihenDaten49>>,
    /// Required (Muss). Fields: datum.format, datum.wert, menge, mengenQualifier, mengeneinheit
    pub zeitreihen_daten49_mengen: Option<ZeitreihenDaten49Mengen>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55223TransaktionStammdaten {
    /// Required entity fields for PID 55223 (DZÜ Liste).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("messlokation", &["mabisZaehlpunktId", "referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
            ("zeitreihen_daten47_mengen", &["datum.format", "datum.wert", "menge", "mengenQualifier", "mengeneinheit"]),
            ("zeitreihen_daten48", &["referenz"]),
            ("zeitreihen_daten48_mengen", &["datum.format", "datum.wert", "menge", "mengenQualifier", "mengeneinheit"]),
            ("zeitreihen_daten49", &["referenz"]),
            ("zeitreihen_daten49_mengen", &["datum.format", "datum.wert", "menge", "mengenQualifier", "mengeneinheit"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55223Interchange = crate::model::Interchange<
    Pid55223MessageStammdaten,
    Pid55223TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55224MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55224: Antwort auf DZÜ Liste
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55224TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: mabisZaehlpunktId, referenz
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ebdNummer, ebdNummer2, ideQualifier, pruefidentifikator, pruefschrittCode, pruefschrittCode2, transaktionsnummer, transaktionsnummer2, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler: Option<Vec<ZaehlerWrapped>>,
    /// Required (Muss). Fields: datum.format, datum.wert, menge, mengenQualifier, mengeneinheit
    pub zaehler_mengen: Option<ZaehlerMengenWrapped>,
}

impl Pid55224TransaktionStammdaten {
    /// Required entity fields for PID 55224 (Antwort auf DZÜ Liste).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("messlokation", &["mabisZaehlpunktId", "referenz"]),
            ("prozessdaten", &["ebdNummer", "ebdNummer2", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "pruefschrittCode2", "transaktionsnummer", "transaktionsnummer2", "vorgangId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
            ("zaehler", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
            ("zaehler_mengen", &["datum.format", "datum.wert", "menge", "mengenQualifier", "mengeneinheit"]),
        ]
    }
}

pub type Pid55224Interchange = crate::model::Interchange<
    Pid55224MessageStammdaten,
    Pid55224TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55225MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55225: Änderung Blindabr.-Daten der NeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55225TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    /// Required (Muss). Fields: merkmal.code, netzlokationsId, produktIdentifikation.id, produktIdentifikation.typ, zahlerBlindarbeit, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55225TransaktionStammdaten {
    /// Required entity fields for PID 55225 (Änderung Blindabr.-Daten der NeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("netzlokation", &["merkmal.code", "netzlokationsId", "produktIdentifikation.id", "produktIdentifikation.typ", "zahlerBlindarbeit", "zeitscheibe.referenz"]),
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55225Interchange = crate::model::Interchange<
    Pid55225MessageStammdaten,
    Pid55225TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55227MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55227: Rückmeldung/Anfrage Blindabr.-Daten der NeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55227TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, netzlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55227TransaktionStammdaten {
    /// Required entity fields for PID 55227 (Rückmeldung/Anfrage Blindabr.-Daten der NeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("netzlokation", &["codelisteCode", "codepflegeCode", "netzlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("technische_ressource", &["merkmal.code", "merkmal.eigenschaft", "produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
        ]
    }
}

pub type Pid55227Interchange = crate::model::Interchange<
    Pid55227MessageStammdaten,
    Pid55227TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55230MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55230: Änderung Blindabr.-Daten der NeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55230TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, merkmal.code, netzlokationsId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55230TransaktionStammdaten {
    /// Required entity fields for PID 55230 (Änderung Blindabr.-Daten der NeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("netzlokation", &["codelisteCode", "codepflegeCode", "merkmal.code", "netzlokationsId", "zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55230Interchange = crate::model::Interchange<
    Pid55230MessageStammdaten,
    Pid55230TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55232MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55232: Rückmeldung/Anfrage Blindabr.-Daten der NeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55232TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    /// Required (Muss). Fields: datenqualitaet, merkmal.code, netzlokationsId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55232TransaktionStammdaten {
    /// Required entity fields for PID 55232 (Rückmeldung/Anfrage Blindabr.-Daten der NeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("netzlokation", &["datenqualitaet", "merkmal.code", "netzlokationsId", "zeitscheibe.referenz"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55232Interchange = crate::model::Interchange<
    Pid55232MessageStammdaten,
    Pid55232TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55235MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55235: Zuordnung ZP der NGZ zur NZR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55235TransaktionStammdaten {
    /// Required (Muss). Fields: produktIdentifikation.id
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub clearing_daten: Option<Vec<ClearingDaten>>,
    /// Required (Muss). Fields: jahresverbrauchsprognose
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId, merkmal.code, merkmal.klasse, merkmal.qualifier, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: gueltigAb, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55235TransaktionStammdaten {
    /// Required entity fields for PID 55235 (Zuordnung ZP der NGZ zur NZR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("clearing_daten", &["produktIdentifikation.id"]),
            ("marktlokation", &["jahresverbrauchsprognose"]),
            ("messlokation", &["mabisZaehlpunktId", "merkmal.code", "merkmal.klasse", "merkmal.qualifier", "referenz"]),
            ("prozessdaten", &["gueltigAb", "ideQualifier", "pruefidentifikator", "vorgangId"]),
        ]
    }
}

pub type Pid55235Interchange = crate::model::Interchange<
    Pid55235MessageStammdaten,
    Pid55235TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55236MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55236: Beendigung Zuordnung ZP der NGZ zur NZR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55236TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: gueltigBis, ideQualifier, pruefidentifikator, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55236TransaktionStammdaten {
    /// Required entity fields for PID 55236 (Beendigung Zuordnung ZP der NGZ zur NZR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["gueltigBis", "ideQualifier", "pruefidentifikator", "vorgangId"]),
        ]
    }
}

pub type Pid55236Interchange = crate::model::Interchange<
    Pid55236MessageStammdaten,
    Pid55236TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55237MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55237: Antwort
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55237TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ebdNummer, gueltigAb, gueltigBis, ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55237TransaktionStammdaten {
    /// Required entity fields for PID 55237 (Antwort).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["ebdNummer", "gueltigAb", "gueltigBis", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55237Interchange = crate::model::Interchange<
    Pid55237MessageStammdaten,
    Pid55237TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55238MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55238: Anmeldung in Modell 2
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55238TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, merkmal.code, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungVon, gueltigAb, ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55238TransaktionStammdaten {
    /// Required entity fields for PID 55238 (Anmeldung in Modell 2).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "merkmal.code", "referenz"]),
            ("prozessdaten", &["aenderungVon", "gueltigAb", "ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55238Interchange = crate::model::Interchange<
    Pid55238MessageStammdaten,
    Pid55238TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55239MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55239: Antwort auf Anmeldung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55239TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, merkmal.code, merkmal.eigenschaft, referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_marktlokation: Option<Vec<ObisMarktlokationWrapped>>,
    /// Required (Muss). Fields: aenderungVon, gueltigAb, ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55239TransaktionStammdaten {
    /// Required entity fields for PID 55239 (Antwort auf Anmeldung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "merkmal.code", "merkmal.eigenschaft", "referenz", "zugeordneterMp"]),
            ("messlokation", &["mabisZaehlpunktId"]),
            ("obis_marktlokation", &["produktIdentifikation.id", "referenz"]),
            ("prozessdaten", &["aenderungVon", "gueltigAb", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55239Interchange = crate::model::Interchange<
    Pid55239MessageStammdaten,
    Pid55239TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55240MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55240: Beendigung der Zuordnung zur MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55240TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungBis, gueltigBis, ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55240TransaktionStammdaten {
    /// Required entity fields for PID 55240 (Beendigung der Zuordnung zur MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("prozessdaten", &["aenderungBis", "gueltigBis", "ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55240Interchange = crate::model::Interchange<
    Pid55240MessageStammdaten,
    Pid55240TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55241MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55241: Antwort auf Beendigung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55241TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungBis, gueltigBis, ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55241TransaktionStammdaten {
    /// Required entity fields for PID 55241 (Antwort auf Beendigung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("prozessdaten", &["aenderungBis", "gueltigBis", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55241Interchange = crate::model::Interchange<
    Pid55241MessageStammdaten,
    Pid55241TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55242MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55242: Abmeldung aus dem Modell 2
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55242TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungBis, gueltigBis, ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55242TransaktionStammdaten {
    /// Required entity fields for PID 55242 (Abmeldung aus dem Modell 2).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungBis", "gueltigBis", "ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55242Interchange = crate::model::Interchange<
    Pid55242MessageStammdaten,
    Pid55242TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55243MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55243: Antwort auf Abmeldung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55243TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: mabisZaehlpunktId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: aenderungBis, gueltigBis, ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55243TransaktionStammdaten {
    /// Required entity fields for PID 55243 (Antwort auf Abmeldung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("messlokation", &["mabisZaehlpunktId"]),
            ("prozessdaten", &["aenderungBis", "gueltigBis", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55243Interchange = crate::model::Interchange<
    Pid55243MessageStammdaten,
    Pid55243TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55553MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55553: Daten auf individuelle Bestellung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55553TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_marktlokation: Option<Vec<ObisMarktlokationWrapped>>,
    /// Required (Muss). Fields: konfigurationsId, produktIdentifikation.id, smartmeterGatewayId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_zaehleinrichtung: Option<Vec<ObisZaehleinrichtungWrapped>>,
    /// Required (Muss). Fields: pruefidentifikator, referenzBestellungsantwort, referenzVorgangsId, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: smartmeterGatewayId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler: Option<Vec<ZaehlerWrapped>>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55553TransaktionStammdaten {
    /// Required entity fields for PID 55553 (Daten auf individuelle Bestellung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("obis_marktlokation", &["produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("obis_zaehleinrichtung", &["konfigurationsId", "produktIdentifikation.id", "smartmeterGatewayId", "zeitscheibe.referenz"]),
            ("prozessdaten", &["pruefidentifikator", "referenzBestellungsantwort", "referenzVorgangsId", "transaktionsgrund", "vorgangId"]),
            ("zaehler", &["smartmeterGatewayId", "zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55553Interchange = crate::model::Interchange<
    Pid55553MessageStammdaten,
    Pid55553TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55555MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55555: Rückmeldung/Anfrage Daten der individuellen Bestellung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55555TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_marktlokation: Option<ObisMarktlokationWrapped>,
    pub obis_zaehleinrichtung: Option<ObisZaehleinrichtungWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, referenzBestellungsantwort, referenzVorgangsId, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler: Option<ZaehlerWrapped>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55555TransaktionStammdaten {
    /// Required entity fields for PID 55555 (Rückmeldung/Anfrage Daten der individuellen Bestellung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "referenzBestellungsantwort", "referenzVorgangsId", "transaktionsgrund", "vorgangId"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55555Interchange = crate::model::Interchange<
    Pid55555MessageStammdaten,
    Pid55555TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55557MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55557: Änderung MSB-Abr.-Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55557TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler: Option<Vec<ZaehlerWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub zaehler_mengen: Option<ZaehlerMengenWrapped>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55557TransaktionStammdaten {
    /// Required entity fields for PID 55557 (Änderung MSB-Abr.-Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("zaehler", &["produktIdentifikation.funktion", "produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("zaehler_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
        ]
    }
}

pub type Pid55557Interchange = crate::model::Interchange<
    Pid55557MessageStammdaten,
    Pid55557TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55559MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55559: Rückmeldung/Anfrage MSB-Abr.-Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55559TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, produktIdentifikation.funktion, produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55559TransaktionStammdaten {
    /// Required entity fields for PID 55559 (Rückmeldung/Anfrage MSB-Abr.-Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "produktIdentifikation.funktion", "produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55559Interchange = crate::model::Interchange<
    Pid55559MessageStammdaten,
    Pid55559TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55600MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55600: Anmeldung neue verb. MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55600TransaktionStammdaten {
    /// Required (Muss). Fields: anredeCode, identifikation, land, nachname, ort, partnerrolle, region, strasse
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: marktlokationsId, merkmal.code
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: priorisierung.produktpaketRef, produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, produkteigenschaft.code, produkteigenschaft.klasse, produkteigenschaft.wert, umsetzungsgrad.klasse, umsetzungsgrad.prioritaet, umsetzungsgrad.relevanz, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub produktpaket_daten: Option<Vec<ProduktpaketDaten>>,
    /// Required (Muss). Fields: gueltigAb, gueltigBis, pruefidentifikator, transaktionsgrund, transaktionsgrundDetail, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.qualifier
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler: Option<Vec<ZaehlerWrapped>>,
}

impl Pid55600TransaktionStammdaten {
    /// Required entity fields for PID 55600 (Anmeldung neue verb. MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["anredeCode", "identifikation", "land", "nachname", "ort", "partnerrolle", "region", "strasse"]),
            ("marktlokation", &["marktlokationsId", "merkmal.code"]),
            ("messlokation", &["messlokationsId"]),
            ("produktpaket_daten", &["priorisierung.produktpaketRef", "produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "produkteigenschaft.code", "produkteigenschaft.klasse", "produkteigenschaft.wert", "umsetzungsgrad.klasse", "umsetzungsgrad.prioritaet", "umsetzungsgrad.relevanz", "zeitscheibe.referenz"]),
            ("prozessdaten", &["gueltigAb", "gueltigBis", "pruefidentifikator", "transaktionsgrund", "transaktionsgrundDetail", "vorgangId"]),
            ("steuerbare_ressource", &["steuerbareRessourceId"]),
            ("technische_ressource", &["technischeRessourceId"]),
            ("zaehler", &["merkmal.code", "merkmal.eigenschaft", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55600Interchange = crate::model::Interchange<
    Pid55600MessageStammdaten,
    Pid55600TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55601MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55601: Anmeldung neue erz. MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55601TransaktionStammdaten {
    /// Required (Muss). Fields: text, textReferenz, textbezug
    pub freitext: Option<Freitext>,
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.strasse, geschaeftspartnerId, name1, partnerrolle
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub produktpaket_daten: Option<Vec<ProduktpaketDaten>>,
    /// Required (Muss). Fields: gueltigAb, ideQualifier, pruefidentifikator, transaktionsgrund, transaktionsgrundDetail, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    pub tranche: Option<Tranche>,
    /// Required (Muss).
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler: Option<Vec<ZaehlerWrapped>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55601TransaktionStammdaten {
    /// Required entity fields for PID 55601 (Anmeldung neue erz. MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textReferenz", "textbezug"]),
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.strasse", "geschaeftspartnerId", "name1", "partnerrolle"]),
            ("marktlokation", &["marktlokationsId"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "messlokationsId"]),
            ("produktpaket_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
            ("prozessdaten", &["gueltigAb", "ideQualifier", "pruefidentifikator", "transaktionsgrund", "transaktionsgrundDetail", "vorgangId"]),
            ("steuerbare_ressource", &["codelisteCode", "codepflegeCode", "steuerbareRessourceId"]),
            ("technische_ressource", &["codelisteCode", "codepflegeCode", "technischeRessourceId"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55601Interchange = crate::model::Interchange<
    Pid55601MessageStammdaten,
    Pid55601TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55602MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55602: Bestätigung Anmeldung neue verb. MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55602TransaktionStammdaten {
    /// Required (Muss). Fields: artLeistungserbringung, eigenschaftMsb, marktlokationsId, merkmalCode, merkmalWert, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: artLeistungserbringung, eigenschaftMsb, gMsbMerkmalWert, gMsbMpId, merkmalCode, merkmalWert, messlokationsId, referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: eigenschaftMsb, merkmalCode, merkmalWert, netzlokationsId, referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: geplantesPaket, gueltigAb, gueltigBis, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: eigenschaftMsb, merkmalCode, merkmalWert, referenz, steuerbareRessourceId, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    pub tranche: Option<Tranche>,
}

impl Pid55602TransaktionStammdaten {
    /// Required entity fields for PID 55602 (Bestätigung Anmeldung neue verb. MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["artLeistungserbringung", "eigenschaftMsb", "marktlokationsId", "merkmalCode", "merkmalWert", "zugeordneterMp"]),
            ("messlokation", &["artLeistungserbringung", "eigenschaftMsb", "gMsbMerkmalWert", "gMsbMpId", "merkmalCode", "merkmalWert", "messlokationsId", "referenz", "zugeordneterMp"]),
            ("netzlokation", &["eigenschaftMsb", "merkmalCode", "merkmalWert", "netzlokationsId", "referenz", "zugeordneterMp"]),
            ("prozessdaten", &["geplantesPaket", "gueltigAb", "gueltigBis", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
            ("steuerbare_ressource", &["eigenschaftMsb", "merkmalCode", "merkmalWert", "referenz", "steuerbareRessourceId", "zugeordneterMp"]),
            ("technische_ressource", &["technischeRessourceId"]),
        ]
    }
}

pub type Pid55602Interchange = crate::model::Interchange<
    Pid55602MessageStammdaten,
    Pid55602TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55603MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55603: Bestätigung Anmeldung neue erz. MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55603TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, jahresverbrauchsprognose, mengeneinheit, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation_daten: Option<Vec<MesslokationDatenWrapped>>,
    /// Required (Muss). Fields: netzlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: gueltigAb, ideQualifier, pruefidentifikator, pruefschrittCode, referenz, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: referenz, steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.eigenschaft_2, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55603TransaktionStammdaten {
    /// Required entity fields for PID 55603 (Bestätigung Anmeldung neue erz. MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "jahresverbrauchsprognose", "mengeneinheit", "messlokationsId"]),
            ("messlokation_daten", &["referenz.id", "referenz.typ"]),
            ("netzlokation", &["netzlokationsId", "referenz"]),
            ("prozessdaten", &["gueltigAb", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "referenz", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
            ("steuerbare_ressource", &["referenz", "steuerbareRessourceId"]),
            ("technische_ressource", &["technischeRessourceId"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.eigenschaft_2", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55603Interchange = crate::model::Interchange<
    Pid55603MessageStammdaten,
    Pid55603TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55604MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55604: Ablehnung Anmeldung neue verb. MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55604TransaktionStammdaten {
    /// Required (Muss). Fields: codelist_code, codepflege_code, identifikation, partnerrolle
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55604TransaktionStammdaten {
    /// Required entity fields for PID 55604 (Ablehnung Anmeldung neue verb. MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["codelist_code", "codepflege_code", "identifikation", "partnerrolle"]),
            ("marktlokation", &["marktlokationsId"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55604Interchange = crate::model::Interchange<
    Pid55604MessageStammdaten,
    Pid55604TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55605MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55605: Ablehnung Anmeldung neue erz. MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55605TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    /// Required (Muss). Fields: adresse.hausnummer, adresse.landescode, adresse.ort, adresse.postleitzahl, adresse.strasse, anrede, codelisteCode, codepflegeCode, geschaeftspartnerId, name1, name2, nameZeile3Feld, nameZeile4Feld, partnerrolle, region, strasseZeile2, strasseZeile4, zusatzinfo
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55605TransaktionStammdaten {
    /// Required entity fields for PID 55605 (Ablehnung Anmeldung neue erz. MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("geschaeftspartner", &["adresse.hausnummer", "adresse.landescode", "adresse.ort", "adresse.postleitzahl", "adresse.strasse", "anrede", "codelisteCode", "codepflegeCode", "geschaeftspartnerId", "name1", "name2", "nameZeile3Feld", "nameZeile4Feld", "partnerrolle", "region", "strasseZeile2", "strasseZeile4", "zusatzinfo"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55605Interchange = crate::model::Interchange<
    Pid55605MessageStammdaten,
    Pid55605TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55607MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55607: (Ankündigung) Zuordnung des LF zur erz. MaLo/ Tranche
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55607TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, jahresverbrauchsprognose, mengeneinheit, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation_daten: Option<Vec<MesslokationDatenWrapped>>,
    /// Required (Muss). Fields: netzlokationsId, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: gueltigAb, gueltigBis, ideQualifier, pruefidentifikator, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: referenz, steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.eigenschaft_2, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55607TransaktionStammdaten {
    /// Required entity fields for PID 55607 ((Ankündigung) Zuordnung des LF zur erz. MaLo/ Tranche).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "jahresverbrauchsprognose", "mengeneinheit", "messlokationsId"]),
            ("messlokation_daten", &["referenz.id", "referenz.typ"]),
            ("netzlokation", &["netzlokationsId", "referenz"]),
            ("prozessdaten", &["gueltigAb", "gueltigBis", "ideQualifier", "pruefidentifikator", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
            ("steuerbare_ressource", &["referenz", "steuerbareRessourceId"]),
            ("technische_ressource", &["technischeRessourceId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.eigenschaft_2", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55607Interchange = crate::model::Interchange<
    Pid55607MessageStammdaten,
    Pid55607TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55608MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55608: Bestätigung Zuordnung des LF zur erz. MaLo/ Tranche
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55608TransaktionStammdaten {
    /// Required (Muss). Fields: text, textReferenz, textbezug
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub produktpaket_daten: Option<Vec<ProduktpaketDaten>>,
    /// Required (Muss). Fields: gueltigAb, gueltigBis, ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55608TransaktionStammdaten {
    /// Required entity fields for PID 55608 (Bestätigung Zuordnung des LF zur erz. MaLo/ Tranche).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textReferenz", "textbezug"]),
            ("produktpaket_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
            ("prozessdaten", &["gueltigAb", "gueltigBis", "ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
            ("zuordnung", &["merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55608Interchange = crate::model::Interchange<
    Pid55608MessageStammdaten,
    Pid55608TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55609MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55609: Ablehnung Zuordnung des LF zur erz. MaLo/ Tranche
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55609TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55609TransaktionStammdaten {
    /// Required entity fields for PID 55609 (Ablehnung Zuordnung des LF zur erz. MaLo/ Tranche).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55609Interchange = crate::model::Interchange<
    Pid55609MessageStammdaten,
    Pid55609TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55611MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55611: Beendigung der Zuordnung
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55611TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: gueltigAb, gueltigBis, ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55611TransaktionStammdaten {
    /// Required entity fields for PID 55611 (Beendigung der Zuordnung).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "messlokationsId"]),
            ("prozessdaten", &["gueltigAb", "gueltigBis", "ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55611Interchange = crate::model::Interchange<
    Pid55611MessageStammdaten,
    Pid55611TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55613MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55613: Abr.-Daten BK-Abr. verb. MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55613TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, jahresverbrauchsprognose, marktlokationsId, mengeneinheit, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub profil: Option<Vec<Profil>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55613TransaktionStammdaten {
    /// Required entity fields for PID 55613 (Abr.-Daten BK-Abr. verb. MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "jahresverbrauchsprognose", "marktlokationsId", "mengeneinheit", "zeitscheibe.referenz"]),
            ("profil", &["zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55613Interchange = crate::model::Interchange<
    Pid55613MessageStammdaten,
    Pid55613TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55614MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55614: Rückmeldung/Anfrage Abr.-Daten BK-Abr. verb. MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55614TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: jahresverbrauchsprognose, mengeneinheit
    pub zaehler: Option<ZaehlerWrapped>,
    /// Required (Muss). Fields: datenqualitaet, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler_daten: Option<Vec<ZaehlerDatenWrapped>>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55614TransaktionStammdaten {
    /// Required entity fields for PID 55614 (Rückmeldung/Anfrage Abr.-Daten BK-Abr. verb. MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("zaehler", &["jahresverbrauchsprognose", "mengeneinheit"]),
            ("zaehler_daten", &["datenqualitaet", "zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55614Interchange = crate::model::Interchange<
    Pid55614MessageStammdaten,
    Pid55614TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55615MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55615: Änderung Daten der NeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55615TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    /// Required (Muss). Fields: merkmal.code, msbEigenschaft, netzlokationsId, zeitscheibe.referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55615TransaktionStammdaten {
    /// Required entity fields for PID 55615 (Änderung Daten der NeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("netzlokation", &["merkmal.code", "msbEigenschaft", "netzlokationsId", "zeitscheibe.referenz", "zugeordneterMp"]),
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55615Interchange = crate::model::Interchange<
    Pid55615MessageStammdaten,
    Pid55615TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55616MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55616: Änderung Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55616TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.ort, adresse.strasse, anredeCode, name1, partnerrolle, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation_daten: Option<Vec<MarktlokationDatenWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl_nutzung: Option<Vec<ObisKennzahlNutzungWrapped>>,
    /// Required (Muss). Fields: merkmal.klasse, merkmal.qualifier_0, merkmal.qualifier_1, merkmal.qualifier_2, merkmal.qualifier_3, merkmal.qualifier_4
    pub obis_kennzahl_nutzung_zuordnung: Option<ObisKennzahlNutzungZuordnung>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, transaktionsgrundDetail, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.eigenschaft_2, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55616TransaktionStammdaten {
    /// Required entity fields for PID 55616 (Änderung Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.ort", "adresse.strasse", "anredeCode", "name1", "partnerrolle", "zeitscheibe.referenz"]),
            ("marktlokation", &["marktlokationsId"]),
            ("marktlokation_daten", &["zeitscheibe.referenz"]),
            ("obis_kennzahl_nutzung", &["produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("obis_kennzahl_nutzung_zuordnung", &["merkmal.klasse", "merkmal.qualifier_0", "merkmal.qualifier_1", "merkmal.qualifier_2", "merkmal.qualifier_3", "merkmal.qualifier_4"]),
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "transaktionsgrundDetail", "vorgangId"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.eigenschaft_2", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55616Interchange = crate::model::Interchange<
    Pid55616MessageStammdaten,
    Pid55616TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55617MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55617: Änderung Daten der TR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55617TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    /// Required (Muss). Fields: netzlokationRef, steuerbareRessourceRef, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource_daten: Option<Vec<TechnischeRessourceDatenWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub technische_ressource_mengen: Option<TechnischeRessourceMengenWrapped>,
    /// Required (Muss). Fields: merkmal.klasse, merkmal.qualifier_0, merkmal.qualifier_1, merkmal.qualifier_2, merkmal.qualifier_3, merkmal.qualifier_4, merkmal.qualifier_5, merkmal.qualifier_6, merkmal.qualifier_7, merkmal.qualifier_8
    pub technische_ressource_zuordnung: Option<TechnischeRessourceZuordnung>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55617TransaktionStammdaten {
    /// Required entity fields for PID 55617 (Änderung Daten der TR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("technische_ressource", &["technischeRessourceId"]),
            ("technische_ressource_daten", &["netzlokationRef", "steuerbareRessourceRef", "zeitscheibe.referenz"]),
            ("technische_ressource_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("technische_ressource_zuordnung", &["merkmal.klasse", "merkmal.qualifier_0", "merkmal.qualifier_1", "merkmal.qualifier_2", "merkmal.qualifier_3", "merkmal.qualifier_4", "merkmal.qualifier_5", "merkmal.qualifier_6", "merkmal.qualifier_7", "merkmal.qualifier_8"]),
        ]
    }
}

pub type Pid55617Interchange = crate::model::Interchange<
    Pid55617MessageStammdaten,
    Pid55617TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55618MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55618: Änderung Daten der SR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55618TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: merkmal.code, msbEigenschaft, steuerbareRessourceId, zeitscheibe.referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55618TransaktionStammdaten {
    /// Required entity fields for PID 55618 (Änderung Daten der SR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("steuerbare_ressource", &["merkmal.code", "msbEigenschaft", "steuerbareRessourceId", "zeitscheibe.referenz", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55618Interchange = crate::model::Interchange<
    Pid55618MessageStammdaten,
    Pid55618TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55619MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55619: Änderung Daten der Tranche
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55619TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55619TransaktionStammdaten {
    /// Required entity fields for PID 55619 (Änderung Daten der Tranche).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["merkmal.code", "merkmal.eigenschaft", "zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
        ]
    }
}

pub type Pid55619Interchange = crate::model::Interchange<
    Pid55619MessageStammdaten,
    Pid55619TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55620MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55620: Änderung Daten der MeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55620TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: gmsbMpId, referenz.id, referenz.typ, seqQualifier, zeitscheibe.referenz, zugeordneterMp, zugeordneterMpLokationstyp, zugeordneterMpMerkmal, zugeordneterMpQualifier, zugeordneterMpRolle
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation_daten: Option<Vec<MesslokationDatenWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55620TransaktionStammdaten {
    /// Required entity fields for PID 55620 (Änderung Daten der MeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["messlokationsId"]),
            ("messlokation_daten", &["gmsbMpId", "referenz.id", "referenz.typ", "seqQualifier", "zeitscheibe.referenz", "zugeordneterMp", "zugeordneterMpLokationstyp", "zugeordneterMpMerkmal", "zugeordneterMpQualifier", "zugeordneterMpRolle"]),
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55620Interchange = crate::model::Interchange<
    Pid55620MessageStammdaten,
    Pid55620TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55621MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55621: Rückmeldung/Anfrage Daten zur NeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55621TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    /// Required (Muss). Fields: merkmal.code, msbEigenschaft, netzlokationsId, zeitscheibe.referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55621TransaktionStammdaten {
    /// Required entity fields for PID 55621 (Rückmeldung/Anfrage Daten zur NeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("netzlokation", &["merkmal.code", "msbEigenschaft", "netzlokationsId", "zeitscheibe.referenz", "zugeordneterMp"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55621Interchange = crate::model::Interchange<
    Pid55621MessageStammdaten,
    Pid55621TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55622MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55622: Rückmeldung/Anfrage Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55622TransaktionStammdaten {
    /// Required (Muss). Fields: anredeCode, land, nachname, ort, partnerrolle, strasse, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: codelisteCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl_nutzung: Option<ObisKennzahlNutzungWrapped>,
    pub produktpaket: Option<ProduktpaketWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55622TransaktionStammdaten {
    /// Required entity fields for PID 55622 (Rückmeldung/Anfrage Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["anredeCode", "land", "nachname", "ort", "partnerrolle", "strasse", "zeitscheibe.referenz"]),
            ("marktlokation", &["codelisteCode", "marktlokationsId"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55622Interchange = crate::model::Interchange<
    Pid55622MessageStammdaten,
    Pid55622TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55623MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55623: Rückmeldung/Anfrage Daten der TR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55623TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, merkmal.klasse, merkmal.qualifier, technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub technische_ressource_mengen: Option<TechnischeRessourceMengenWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55623TransaktionStammdaten {
    /// Required entity fields for PID 55623 (Rückmeldung/Anfrage Daten der TR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("technische_ressource", &["codelisteCode", "merkmal.klasse", "merkmal.qualifier", "technischeRessourceId"]),
            ("technische_ressource_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
        ]
    }
}

pub type Pid55623Interchange = crate::model::Interchange<
    Pid55623MessageStammdaten,
    Pid55623TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55624MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55624: Rückmeldung/Anfrage Daten der SR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55624TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: merkmal.code, msbEigenschaft, steuerbareRessourceId, zeitscheibe.referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55624TransaktionStammdaten {
    /// Required entity fields for PID 55624 (Rückmeldung/Anfrage Daten der SR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("steuerbare_ressource", &["merkmal.code", "msbEigenschaft", "steuerbareRessourceId", "zeitscheibe.referenz", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55624Interchange = crate::model::Interchange<
    Pid55624MessageStammdaten,
    Pid55624TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55625MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55625: Rückmeldung/Anfrage Daten der Tranche
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55625TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55625TransaktionStammdaten {
    /// Required entity fields for PID 55625 (Rückmeldung/Anfrage Daten der Tranche).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("technische_ressource", &["merkmal.code", "merkmal.eigenschaft", "zeitscheibe.referenz"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
        ]
    }
}

pub type Pid55625Interchange = crate::model::Interchange<
    Pid55625MessageStammdaten,
    Pid55625TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55626MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55626: Rückmeldung/Anfrage Daten der MeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55626TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: abrechnungMsbUeberNne, artLeistungserbringung, gmsbMpId, merkmal.code, messlokationsId, msbEigenschaft, zeitscheibe.referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55626TransaktionStammdaten {
    /// Required entity fields for PID 55626 (Rückmeldung/Anfrage Daten der MeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["abrechnungMsbUeberNne", "artLeistungserbringung", "gmsbMpId", "merkmal.code", "messlokationsId", "msbEigenschaft", "zeitscheibe.referenz", "zugeordneterMp"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55626Interchange = crate::model::Interchange<
    Pid55626MessageStammdaten,
    Pid55626TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55627MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55627: Änderung Daten der NeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55627TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, merkmal.code, merkmal.eigenschaft, netzlokationsId, zeitscheibe.referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55627TransaktionStammdaten {
    /// Required entity fields for PID 55627 (Änderung Daten der NeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("netzlokation", &["codelisteCode", "codepflegeCode", "merkmal.code", "merkmal.eigenschaft", "netzlokationsId", "zeitscheibe.referenz", "zugeordneterMp"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55627Interchange = crate::model::Interchange<
    Pid55627MessageStammdaten,
    Pid55627TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55628MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55628: Änderung Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55628TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.ort, adresse.strasse, anredeCode, name1, partnerrolle, referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub profil_daten: Option<Vec<ProfilDaten>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, transaktionsgrundDetail, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub referenzprofil: Option<Vec<Referenzprofil>>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55628TransaktionStammdaten {
    /// Required entity fields for PID 55628 (Änderung Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.ort", "adresse.strasse", "anredeCode", "name1", "partnerrolle", "referenz"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "zeitscheibe.referenz"]),
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("profil_daten", &["zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "transaktionsgrundDetail", "vorgangId"]),
            ("referenzprofil", &["zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55628Interchange = crate::model::Interchange<
    Pid55628MessageStammdaten,
    Pid55628TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55629MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55629: Änderung Daten der TR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55629TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, referenz, technischeRessourceId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55629TransaktionStammdaten {
    /// Required entity fields for PID 55629 (Änderung Daten der TR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("technische_ressource", &["codelisteCode", "codepflegeCode", "referenz", "technischeRessourceId", "zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55629Interchange = crate::model::Interchange<
    Pid55629MessageStammdaten,
    Pid55629TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55630MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55630: Änderung Daten der SR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55630TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, merkmal.code, merkmal.eigenschaft, steuerbareRessourceId, zeitscheibe.referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55630TransaktionStammdaten {
    /// Required entity fields for PID 55630 (Änderung Daten der SR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("steuerbare_ressource", &["codelisteCode", "codepflegeCode", "merkmal.code", "merkmal.eigenschaft", "steuerbareRessourceId", "zeitscheibe.referenz", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55630Interchange = crate::model::Interchange<
    Pid55630MessageStammdaten,
    Pid55630TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55632MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55632: Änderung Daten der MeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55632TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, merkmal.code, merkmal.eigenschaft, merkmal.eigenschaft_2, merkmal.klasse, messlokationsId, zeitscheibe.referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55632TransaktionStammdaten {
    /// Required entity fields for PID 55632 (Änderung Daten der MeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["codelisteCode", "codepflegeCode", "merkmal.code", "merkmal.eigenschaft", "merkmal.eigenschaft_2", "merkmal.klasse", "messlokationsId", "zeitscheibe.referenz", "zugeordneterMp"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55632Interchange = crate::model::Interchange<
    Pid55632MessageStammdaten,
    Pid55632TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55633MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55633: Rückmeldung/Anfrage Daten zur NeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55633TransaktionStammdaten {
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, zeitscheibe.referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, netzlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55633TransaktionStammdaten {
    /// Required entity fields for PID 55633 (Rückmeldung/Anfrage Daten zur NeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["merkmal.code", "merkmal.eigenschaft", "zeitscheibe.referenz", "zugeordneterMp"]),
            ("netzlokation", &["codelisteCode", "codepflegeCode", "netzlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55633Interchange = crate::model::Interchange<
    Pid55633MessageStammdaten,
    Pid55633TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55634MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55634: Rückmeldung/Anfrage Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55634TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.strasse, name1, partnerrolle
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: datenqualitaet, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler_daten: Option<Vec<ZaehlerDatenWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub zaehler_mengen: Option<ZaehlerMengenWrapped>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55634TransaktionStammdaten {
    /// Required entity fields for PID 55634 (Rückmeldung/Anfrage Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.strasse", "name1", "partnerrolle"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
            ("zaehler_daten", &["datenqualitaet", "zeitscheibe.referenz"]),
            ("zaehler_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55634Interchange = crate::model::Interchange<
    Pid55634MessageStammdaten,
    Pid55634TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55635MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55635: Rückmeldung/Anfrage Daten der TR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55635TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, referenz, technischeRessourceId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55635TransaktionStammdaten {
    /// Required entity fields for PID 55635 (Rückmeldung/Anfrage Daten der TR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("technische_ressource", &["codelisteCode", "codepflegeCode", "referenz", "technischeRessourceId", "zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55635Interchange = crate::model::Interchange<
    Pid55635MessageStammdaten,
    Pid55635TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55636MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55636: Rückmeldung/Anfrage Daten der SR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55636TransaktionStammdaten {
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, zeitscheibe.referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55636TransaktionStammdaten {
    /// Required entity fields for PID 55636 (Rückmeldung/Anfrage Daten der SR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["merkmal.code", "merkmal.eigenschaft", "zeitscheibe.referenz", "zugeordneterMp"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("steuerbare_ressource", &["codelisteCode", "codepflegeCode", "steuerbareRessourceId"]),
        ]
    }
}

pub type Pid55636Interchange = crate::model::Interchange<
    Pid55636MessageStammdaten,
    Pid55636TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55638MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55638: Rückmeldung/Anfrage Daten der MeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55638TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.eigenschaft_2, merkmal.klasse, zeitscheibe.referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55638TransaktionStammdaten {
    /// Required entity fields for PID 55638 (Rückmeldung/Anfrage Daten der MeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("messlokation", &["codelisteCode", "codepflegeCode", "messlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("technische_ressource", &["merkmal.code", "merkmal.eigenschaft", "merkmal.eigenschaft_2", "merkmal.klasse", "zeitscheibe.referenz", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55638Interchange = crate::model::Interchange<
    Pid55638MessageStammdaten,
    Pid55638TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55639MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55639: Änderung Daten der NeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55639TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, netzlokationsId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl: Option<Vec<ObisKennzahlWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub produktpaket: Option<Vec<ProduktpaketWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55639TransaktionStammdaten {
    /// Required entity fields for PID 55639 (Änderung Daten der NeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("netzlokation", &["codelisteCode", "codepflegeCode", "netzlokationsId", "zeitscheibe.referenz"]),
            ("obis_kennzahl", &["produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("produktpaket", &["produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55639Interchange = crate::model::Interchange<
    Pid55639MessageStammdaten,
    Pid55639TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55640MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55640: Änderung Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55640TransaktionStammdaten {
    /// Required (Muss). Fields: marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl: Option<Vec<ObisKennzahlWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub produktpaket: Option<Vec<ProduktpaketWrapped>>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, transaktionsgrundDetail, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: termindatenReferenz, turnusablesung, turnusablesungFormat
    pub termindaten: Option<TermindatenWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    pub zuordnung_obis: Option<ZuordnungObis>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse
    pub zuordnung_produkt: Option<ZuordnungProdukt>,
}

impl Pid55640TransaktionStammdaten {
    /// Required entity fields for PID 55640 (Änderung Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["marktlokationsId"]),
            ("obis_kennzahl", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
            ("produktpaket", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "transaktionsgrundDetail", "vorgangId"]),
            ("termindaten", &["termindatenReferenz", "turnusablesung", "turnusablesungFormat"]),
            ("zuordnung_obis", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
            ("zuordnung_produkt", &["merkmal.code", "merkmal.klasse"]),
        ]
    }
}

pub type Pid55640Interchange = crate::model::Interchange<
    Pid55640MessageStammdaten,
    Pid55640TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55641MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55641: Änderung Daten der SR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55641TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource_daten: Option<Vec<SteuerbareRessourceDatenWrapped>>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55641TransaktionStammdaten {
    /// Required entity fields for PID 55641 (Änderung Daten der SR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("steuerbare_ressource", &["codelisteCode", "codepflegeCode", "steuerbareRessourceId"]),
            ("steuerbare_ressource_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz", "zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55641Interchange = crate::model::Interchange<
    Pid55641MessageStammdaten,
    Pid55641TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55642MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55642: Änderung Daten der Tranche
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55642TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: merkmal.code, merkmal.qualifier, produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl_daten: Option<Vec<ObisKennzahlDatenWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55642TransaktionStammdaten {
    /// Required entity fields for PID 55642 (Änderung Daten der Tranche).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("obis_kennzahl_daten", &["merkmal.code", "merkmal.qualifier", "produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
        ]
    }
}

pub type Pid55642Interchange = crate::model::Interchange<
    Pid55642MessageStammdaten,
    Pid55642TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55643MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55643: Änderung Daten der MeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55643TransaktionStammdaten {
    /// Required (Muss). Fields: anredeCode, identifikation, land, nachname, ort, partnerrolle, postleitzahl, region, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, messlokationsId, referenz, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: konfigurationsId, produktIdentifikation.id, rffGeraetNummer, rffQualifierGeraet, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl: Option<Vec<ObisKennzahlWrapped>>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: referenz, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler_daten: Option<Vec<ZaehlerDatenWrapped>>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55643TransaktionStammdaten {
    /// Required entity fields for PID 55643 (Änderung Daten der MeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["anredeCode", "identifikation", "land", "nachname", "ort", "partnerrolle", "postleitzahl", "region", "zeitscheibe.referenz"]),
            ("messlokation", &["codelisteCode", "messlokationsId", "referenz", "zeitscheibe.referenz"]),
            ("obis_kennzahl", &["konfigurationsId", "produktIdentifikation.id", "rffGeraetNummer", "rffQualifierGeraet", "zeitscheibe.referenz"]),
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("zaehler_daten", &["referenz", "zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55643Interchange = crate::model::Interchange<
    Pid55643MessageStammdaten,
    Pid55643TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55644MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55644: Rückmeldung/Anfrage Daten der NeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55644TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: datenqualitaet, produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation_daten: Option<Vec<MarktlokationDatenWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, netzlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55644TransaktionStammdaten {
    /// Required entity fields for PID 55644 (Rückmeldung/Anfrage Daten der NeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation_daten", &["datenqualitaet", "produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
            ("netzlokation", &["codelisteCode", "codepflegeCode", "netzlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("technische_ressource", &["produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55644Interchange = crate::model::Interchange<
    Pid55644MessageStammdaten,
    Pid55644TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55645MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55645: Rückmeldung/Anfrage Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55645TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: datenqualitaet, produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation_daten: Option<Vec<MarktlokationDatenWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55645TransaktionStammdaten {
    /// Required entity fields for PID 55645 (Rückmeldung/Anfrage Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("marktlokation_daten", &["datenqualitaet", "produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55645Interchange = crate::model::Interchange<
    Pid55645MessageStammdaten,
    Pid55645TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55646MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55646: Rückmeldung/Anfrage Daten der SR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55646TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: datenqualitaet, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource_daten: Option<Vec<SteuerbareRessourceDatenWrapped>>,
    /// Required (Muss). Fields: datenqualitaet, produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource_produkt_daten: Option<Vec<SteuerbareRessourceProduktDatenWrapped>>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55646TransaktionStammdaten {
    /// Required entity fields for PID 55646 (Rückmeldung/Anfrage Daten der SR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("steuerbare_ressource", &["codelisteCode", "codepflegeCode", "steuerbareRessourceId"]),
            ("steuerbare_ressource_daten", &["datenqualitaet", "zeitscheibe.referenz"]),
            ("steuerbare_ressource_produkt_daten", &["datenqualitaet", "produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55646Interchange = crate::model::Interchange<
    Pid55646MessageStammdaten,
    Pid55646TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55647MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55647: Rückmeldung/Anfrage Daten der Tranche
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55647TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.qualifier, produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler: Option<Vec<ZaehlerWrapped>>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55647TransaktionStammdaten {
    /// Required entity fields for PID 55647 (Rückmeldung/Anfrage Daten der Tranche).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
            ("zaehler", &["merkmal.code", "merkmal.qualifier", "produktIdentifikation.id", "zeitscheibe.referenz"]),
        ]
    }
}

pub type Pid55647Interchange = crate::model::Interchange<
    Pid55647MessageStammdaten,
    Pid55647TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55648MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55648: Rückmeldung/Anfrage Daten der MeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55648TransaktionStammdaten {
    /// Required (Muss). Fields: land, nachname, ort, partnerrolle, strasse
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: datenqualitaet, referenz, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler_daten: Option<Vec<ZaehlerDatenWrapped>>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55648TransaktionStammdaten {
    /// Required entity fields for PID 55648 (Rückmeldung/Anfrage Daten der MeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["land", "nachname", "ort", "partnerrolle", "strasse"]),
            ("messlokation", &["codelisteCode", "messlokationsId"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("zaehler_daten", &["datenqualitaet", "referenz", "zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55648Interchange = crate::model::Interchange<
    Pid55648MessageStammdaten,
    Pid55648TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55649MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55649: Änderung Daten der NeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55649TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    /// Required (Muss). Fields: netzlokationsId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl: Option<Vec<ObisKennzahlWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub produktpaket: Option<Vec<ProduktpaketWrapped>>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55649TransaktionStammdaten {
    /// Required entity fields for PID 55649 (Änderung Daten der NeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("netzlokation", &["netzlokationsId", "zeitscheibe.referenz"]),
            ("obis_kennzahl", &["produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
            ("produktpaket", &["produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55649Interchange = crate::model::Interchange<
    Pid55649MessageStammdaten,
    Pid55649TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55650MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55650: Änderung Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55650TransaktionStammdaten {
    /// Required (Muss). Fields: marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl: Option<Vec<ObisKennzahlWrapped>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, merkmal.qualifier2, merkmal.qualifier3
    pub obis_kennzahl_zuordnung: Option<ObisKennzahlZuordnungWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub produktpaket: Option<Vec<ProduktpaketWrapped>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse
    pub produktpaket_zuordnung: Option<ProduktpaketZuordnung>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, transaktionsgrundDetail, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: termindatenReferenz, turnusablesung, turnusablesungFormat
    pub termindaten: Option<TermindatenWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55650TransaktionStammdaten {
    /// Required entity fields for PID 55650 (Änderung Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["marktlokationsId"]),
            ("obis_kennzahl", &["produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
            ("obis_kennzahl_zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "merkmal.qualifier2", "merkmal.qualifier3"]),
            ("produktpaket", &["produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
            ("produktpaket_zuordnung", &["merkmal.code", "merkmal.klasse"]),
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "transaktionsgrundDetail", "vorgangId"]),
            ("termindaten", &["termindatenReferenz", "turnusablesung", "turnusablesungFormat"]),
        ]
    }
}

pub type Pid55650Interchange = crate::model::Interchange<
    Pid55650MessageStammdaten,
    Pid55650TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55651MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55651: Änderung Daten der SR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55651TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource_daten: Option<Vec<SteuerbareRessourceDatenWrapped>>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55651TransaktionStammdaten {
    /// Required entity fields for PID 55651 (Änderung Daten der SR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("steuerbare_ressource", &["steuerbareRessourceId"]),
            ("steuerbare_ressource_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz", "zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55651Interchange = crate::model::Interchange<
    Pid55651MessageStammdaten,
    Pid55651TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55652MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55652: Änderung Daten der Tranche
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55652TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: merkmal.code, merkmal.qualifier, produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl_daten: Option<Vec<ObisKennzahlDatenWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55652TransaktionStammdaten {
    /// Required entity fields for PID 55652 (Änderung Daten der Tranche).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("obis_kennzahl_daten", &["merkmal.code", "merkmal.qualifier", "produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
        ]
    }
}

pub type Pid55652Interchange = crate::model::Interchange<
    Pid55652MessageStammdaten,
    Pid55652TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55653MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55653: Änderung Daten der MeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55653TransaktionStammdaten {
    /// Required (Muss). Fields: anredeCode, codelisteCode, identifikation, land, nachname, ort, partnerrolle, region, strasse, zeitscheibe.referenz, zusatzinfo
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: messlokationsId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: geraetereferenzNummer, geraetereferenzQualifier, konfigurationsId, produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl: Option<Vec<ObisKennzahlWrapped>>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: energierichtungErz, energierichtungZrz, geraeteNummer, merkmal.code, referenz, tarifartEtz, tarifartNtz, tarifartZtz, zaehlerart, zaehlertyp, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler_daten: Option<Vec<ZaehlerDatenWrapped>>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.qualifier, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zuordnung_gateway: Option<Vec<ZuordnungGateway>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.qualifier
    pub zuordnung_messlokation: Option<ZuordnungMesslokation>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    pub zuordnung_obis: Option<ZuordnungObis>,
    /// Required (Muss). Fields: geraeteNr1, geraeteNr2, geraeteNr3, geraetereferenz, merkmal.code, wandlerfaktor, wandlerfaktorCode, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zuordnung_wandler: Option<Vec<ZuordnungWandler>>,
}

impl Pid55653TransaktionStammdaten {
    /// Required entity fields for PID 55653 (Änderung Daten der MeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["anredeCode", "codelisteCode", "identifikation", "land", "nachname", "ort", "partnerrolle", "region", "strasse", "zeitscheibe.referenz", "zusatzinfo"]),
            ("messlokation", &["messlokationsId", "zeitscheibe.referenz"]),
            ("obis_kennzahl", &["geraetereferenzNummer", "geraetereferenzQualifier", "konfigurationsId", "produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "vorgangId"]),
            ("zaehler_daten", &["energierichtungErz", "energierichtungZrz", "geraeteNummer", "merkmal.code", "referenz", "tarifartEtz", "tarifartNtz", "tarifartZtz", "zaehlerart", "zaehlertyp", "zeitscheibe.referenz"]),
            ("zuordnung_gateway", &["merkmal.code", "merkmal.eigenschaft", "merkmal.qualifier", "zeitscheibe.referenz"]),
            ("zuordnung_messlokation", &["merkmal.code", "merkmal.qualifier"]),
            ("zuordnung_obis", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
            ("zuordnung_wandler", &["geraeteNr1", "geraeteNr2", "geraeteNr3", "geraetereferenz", "merkmal.code", "wandlerfaktor", "wandlerfaktorCode", "zeitscheibe.referenz"]),
        ]
    }
}

pub type Pid55653Interchange = crate::model::Interchange<
    Pid55653MessageStammdaten,
    Pid55653TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55654MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55654: Rückmeldung/Anfrage Daten der NeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55654TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, netzlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    pub produktpaket: Option<ProduktpaketWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55654TransaktionStammdaten {
    /// Required entity fields for PID 55654 (Rückmeldung/Anfrage Daten der NeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("netzlokation", &["codelisteCode", "netzlokationsId"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55654Interchange = crate::model::Interchange<
    Pid55654MessageStammdaten,
    Pid55654TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55655MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55655: Rückmeldung/Anfrage Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55655TransaktionStammdaten {
    /// Required (Muss). Fields: marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: datenqualitaet, produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation_obis_daten: Option<Vec<MarktlokationObisDatenWrapped>>,
    /// Required (Muss). Fields: datenqualitaet, produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation_produkt_daten: Option<Vec<MarktlokationProduktDatenWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    pub obis_kennzahl_zuordnung: Option<ObisKennzahlZuordnungWrapped>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse
    pub produktpaket_zuordnung: Option<ProduktpaketZuordnung>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub termindaten: Option<TermindatenWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55655TransaktionStammdaten {
    /// Required entity fields for PID 55655 (Rückmeldung/Anfrage Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["marktlokationsId"]),
            ("marktlokation_obis_daten", &["datenqualitaet", "produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
            ("marktlokation_produkt_daten", &["datenqualitaet", "produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
            ("obis_kennzahl_zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
            ("produktpaket_zuordnung", &["merkmal.code", "merkmal.klasse"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55655Interchange = crate::model::Interchange<
    Pid55655MessageStammdaten,
    Pid55655TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55656MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55656: Rückmeldung/Anfrage Daten der SR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55656TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: datenqualitaet, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource_daten: Option<Vec<SteuerbareRessourceDatenWrapped>>,
    /// Required (Muss). Fields: datenqualitaet, produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource_produkt_daten: Option<Vec<SteuerbareRessourceProduktDatenWrapped>>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55656TransaktionStammdaten {
    /// Required entity fields for PID 55656 (Rückmeldung/Anfrage Daten der SR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("steuerbare_ressource", &["codelisteCode", "codepflegeCode", "steuerbareRessourceId"]),
            ("steuerbare_ressource_daten", &["datenqualitaet", "zeitscheibe.referenz"]),
            ("steuerbare_ressource_produkt_daten", &["datenqualitaet", "produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55656Interchange = crate::model::Interchange<
    Pid55656MessageStammdaten,
    Pid55656TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55657MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55657: Rückmeldung/Anfrage Daten der Tranche
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55657TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.qualifier, produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler: Option<Vec<ZaehlerWrapped>>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55657TransaktionStammdaten {
    /// Required entity fields for PID 55657 (Rückmeldung/Anfrage Daten der Tranche).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
            ("zaehler", &["merkmal.code", "merkmal.qualifier", "produktIdentifikation.id", "zeitscheibe.referenz"]),
        ]
    }
}

pub type Pid55657Interchange = crate::model::Interchange<
    Pid55657MessageStammdaten,
    Pid55657TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55658MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55658: Rückmeldung/Anfrage Daten der MeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55658TransaktionStammdaten {
    /// Required (Muss). Fields: anredeCode, land, nachname, ort, partnerrolle, strasse, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: datenqualitaet, referenz, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler_daten: Option<Vec<ZaehlerDatenWrapped>>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55658TransaktionStammdaten {
    /// Required entity fields for PID 55658 (Rückmeldung/Anfrage Daten der MeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["anredeCode", "land", "nachname", "ort", "partnerrolle", "strasse", "zeitscheibe.referenz"]),
            ("messlokation", &["codelisteCode", "messlokationsId"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("zaehler_daten", &["datenqualitaet", "referenz", "zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55658Interchange = crate::model::Interchange<
    Pid55658MessageStammdaten,
    Pid55658TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55659MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55659: Änderung Daten der NeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55659TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, netzlokationsId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl: Option<Vec<ObisKennzahlWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub produktpaket: Option<Vec<ProduktpaketWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55659TransaktionStammdaten {
    /// Required entity fields for PID 55659 (Änderung Daten der NeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("netzlokation", &["codelisteCode", "codepflegeCode", "netzlokationsId", "zeitscheibe.referenz"]),
            ("obis_kennzahl", &["produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("produktpaket", &["produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55659Interchange = crate::model::Interchange<
    Pid55659MessageStammdaten,
    Pid55659TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55660MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55660: Änderung Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55660TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_marktlokation: Option<Vec<ObisMarktlokationWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub produktpaket: Option<Vec<ProduktpaketWrapped>>,
    /// Required (Muss). Fields: datumZ50, ideQualifier, pruefidentifikator, referenz, transaktionsgrund, transaktionsgrundDetail, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55660TransaktionStammdaten {
    /// Required entity fields for PID 55660 (Änderung Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("obis_marktlokation", &["produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("produktpaket", &["produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("prozessdaten", &["datumZ50", "ideQualifier", "pruefidentifikator", "referenz", "transaktionsgrund", "transaktionsgrundDetail", "vorgangId"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55660Interchange = crate::model::Interchange<
    Pid55660MessageStammdaten,
    Pid55660TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55661MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55661: Änderung Daten der SR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55661TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource_daten: Option<Vec<SteuerbareRessourceDatenWrapped>>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55661TransaktionStammdaten {
    /// Required entity fields for PID 55661 (Änderung Daten der SR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("steuerbare_ressource", &["codelisteCode", "codepflegeCode", "steuerbareRessourceId"]),
            ("steuerbare_ressource_daten", &["produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55661Interchange = crate::model::Interchange<
    Pid55661MessageStammdaten,
    Pid55661TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55662MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55662: Änderung Daten der Tranche
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55662TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: merkmal.code, merkmal.qualifier, produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl_daten: Option<Vec<ObisKennzahlDatenWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55662TransaktionStammdaten {
    /// Required entity fields for PID 55662 (Änderung Daten der Tranche).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("obis_kennzahl_daten", &["merkmal.code", "merkmal.qualifier", "produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
        ]
    }
}

pub type Pid55662Interchange = crate::model::Interchange<
    Pid55662MessageStammdaten,
    Pid55662TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55663MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55663: Änderung Daten der MeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55663TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.postleitzahl, anredeCode, codelisteCode, codepflegeCode, geschaeftspartnerId, name1, partnerrolle, referenz, region
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, messlokationsId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, referenz, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_zaehleinrichtung: Option<Vec<ObisZaehleinrichtungWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: referenz.id, referenz.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler_daten: Option<Vec<ZaehlerDatenWrapped>>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55663TransaktionStammdaten {
    /// Required entity fields for PID 55663 (Änderung Daten der MeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.postleitzahl", "anredeCode", "codelisteCode", "codepflegeCode", "geschaeftspartnerId", "name1", "partnerrolle", "referenz", "region"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "messlokationsId", "zeitscheibe.referenz"]),
            ("obis_zaehleinrichtung", &["produktIdentifikation.id", "referenz", "zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("zaehler_daten", &["referenz.id", "referenz.typ", "zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55663Interchange = crate::model::Interchange<
    Pid55663MessageStammdaten,
    Pid55663TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55664MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55664: Rückmeldung/Anfrage Daten der NeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55664TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: datenqualitaet, produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation_daten: Option<Vec<MarktlokationDatenWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, netzlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55664TransaktionStammdaten {
    /// Required entity fields for PID 55664 (Rückmeldung/Anfrage Daten der NeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation_daten", &["datenqualitaet", "produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
            ("netzlokation", &["codelisteCode", "codepflegeCode", "netzlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("technische_ressource", &["produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55664Interchange = crate::model::Interchange<
    Pid55664MessageStammdaten,
    Pid55664TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55665MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55665: Rückmeldung/Anfrage Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55665TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: datenqualitaet, produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation_daten: Option<Vec<MarktlokationDatenWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55665TransaktionStammdaten {
    /// Required entity fields for PID 55665 (Rückmeldung/Anfrage Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("marktlokation_daten", &["datenqualitaet", "produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55665Interchange = crate::model::Interchange<
    Pid55665MessageStammdaten,
    Pid55665TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55666MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55666: Rückmeldung/Anfrage Daten der SR
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55666TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: datenqualitaet, produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation_daten: Option<Vec<MarktlokationDatenWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, steuerbareRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55666TransaktionStammdaten {
    /// Required entity fields for PID 55666 (Rückmeldung/Anfrage Daten der SR).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation_daten", &["datenqualitaet", "produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("steuerbare_ressource", &["codelisteCode", "codepflegeCode", "steuerbareRessourceId"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55666Interchange = crate::model::Interchange<
    Pid55666MessageStammdaten,
    Pid55666TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55667MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55667: Rückmeldung/Anfrage Daten der Tranche
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55667TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.qualifier, produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler: Option<Vec<ZaehlerWrapped>>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55667TransaktionStammdaten {
    /// Required entity fields for PID 55667 (Rückmeldung/Anfrage Daten der Tranche).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
            ("zaehler", &["merkmal.code", "merkmal.qualifier", "produktIdentifikation.id", "zeitscheibe.referenz"]),
        ]
    }
}

pub type Pid55667Interchange = crate::model::Interchange<
    Pid55667MessageStammdaten,
    Pid55667TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55669MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55669: Rückmeldung/Anfrage Daten der MeLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55669TransaktionStammdaten {
    /// Required (Muss). Fields: adresse.landescode, adresse.ort, adresse.strasse, name1, partnerrolle
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub geschaeftspartner: Option<BTreeMap<GeschaeftspartnerKey, GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    /// Required (Muss). Fields: datenqualitaet, produktIdentifikation.funktion, produktIdentifikation.id, produktIdentifikation.typ, referenz.id, referenz.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation_daten: Option<Vec<MarktlokationDatenWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, messlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.qualifier
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55669TransaktionStammdaten {
    /// Required entity fields for PID 55669 (Rückmeldung/Anfrage Daten der MeLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["adresse.landescode", "adresse.ort", "adresse.strasse", "name1", "partnerrolle"]),
            ("marktlokation_daten", &["datenqualitaet", "produktIdentifikation.funktion", "produktIdentifikation.id", "produktIdentifikation.typ", "referenz.id", "referenz.typ", "zeitscheibe.referenz"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "messlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.qualifier"]),
        ]
    }
}

pub type Pid55669Interchange = crate::model::Interchange<
    Pid55669MessageStammdaten,
    Pid55669TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55670MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55670: Stammdaten BK-Treue
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55670TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: referenz, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, transaktionsgrundDetail, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55670TransaktionStammdaten {
    /// Required entity fields for PID 55670 (Stammdaten BK-Treue).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "zeitscheibe.referenz"]),
            ("messlokation", &["referenz", "zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "transaktionsgrundDetail", "vorgangId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55670Interchange = crate::model::Interchange<
    Pid55670MessageStammdaten,
    Pid55670TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55671MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55671: Rückmeldung auf Stammdaten BK-Treue
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55671TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: referenz, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler: Option<Vec<ZaehlerWrapped>>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55671TransaktionStammdaten {
    /// Required entity fields for PID 55671 (Rückmeldung auf Stammdaten BK-Treue).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
            ("technische_ressource", &["referenz", "zeitscheibe.referenz"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
            ("zaehler", &["zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55671Interchange = crate::model::Interchange<
    Pid55671MessageStammdaten,
    Pid55671TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55672MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55672: Abr.-Daten BK-Abr. erz. Malo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55672TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    /// Required (Muss). Fields: zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub profil_daten: Option<Vec<ProfilDaten>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, transaktionsgrundDetail, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub referenzprofil: Option<Vec<Referenzprofil>>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.code_codepflege, merkmal.codeliste, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55672TransaktionStammdaten {
    /// Required entity fields for PID 55672 (Abr.-Daten BK-Abr. erz. Malo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "zeitscheibe.referenz"]),
            ("marktlokation_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("messlokation", &["zeitscheibe.referenz"]),
            ("profil_daten", &["zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "transaktionsgrundDetail", "vorgangId"]),
            ("referenzprofil", &["zeitscheibe.referenz"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
            ("zuordnung", &["merkmal.code", "merkmal.code_codepflege", "merkmal.codeliste", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55672Interchange = crate::model::Interchange<
    Pid55672MessageStammdaten,
    Pid55672TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55673MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55673: Rückmeldung/Anfrage Abr.-Daten BK-Abr. erz. Malo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55673TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: datenqualitaet, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler_daten: Option<Vec<ZaehlerDatenWrapped>>,
    /// Required (Muss). Fields: menge, mengenQualifier, mengeneinheit
    pub zaehler_mengen: Option<ZaehlerMengenWrapped>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55673TransaktionStammdaten {
    /// Required entity fields for PID 55673 (Rückmeldung/Anfrage Abr.-Daten BK-Abr. erz. Malo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
            ("technische_ressource", &["zeitscheibe.referenz"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
            ("zaehler_daten", &["datenqualitaet", "zeitscheibe.referenz"]),
            ("zaehler_mengen", &["menge", "mengenQualifier", "mengeneinheit"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse"]),
        ]
    }
}

pub type Pid55673Interchange = crate::model::Interchange<
    Pid55673MessageStammdaten,
    Pid55673TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55674MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55674: Abr.-Daten BK-Abr. erz. Malo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55674TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, transaktionsgrundDetail, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55674TransaktionStammdaten {
    /// Required entity fields for PID 55674 (Abr.-Daten BK-Abr. erz. Malo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "zeitscheibe.referenz"]),
            ("messlokation", &["zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "transaktionsgrundDetail", "vorgangId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55674Interchange = crate::model::Interchange<
    Pid55674MessageStammdaten,
    Pid55674TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55675MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55675: Rückmeldung/Anfrage Abr.-Daten BK-Abr. erz. Malo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55675TransaktionStammdaten {
    /// Required (Muss). Fields: text, textbezug
    pub freitext: Option<Freitext>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsgrundDetail, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    /// Required (Muss). Fields: zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler: Option<Vec<ZaehlerWrapped>>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55675TransaktionStammdaten {
    /// Required entity fields for PID 55675 (Rückmeldung/Anfrage Abr.-Daten BK-Abr. erz. Malo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("freitext", &["text", "textbezug"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsgrundDetail", "transaktionsnummer", "vorgangId"]),
            ("technische_ressource", &["zeitscheibe.referenz"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
            ("zaehler", &["zeitscheibe.referenz"]),
            ("zuordnung", &["merkmal.code", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55675Interchange = crate::model::Interchange<
    Pid55675MessageStammdaten,
    Pid55675TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55684MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55684: Änderung Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55684TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: merkmal.code, merkmal.qualifier
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    /// Required (Muss). Fields: produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_marktlokation: Option<Vec<ObisMarktlokationWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55684TransaktionStammdaten {
    /// Required entity fields for PID 55684 (Änderung Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("obis_kennzahl", &["merkmal.code", "merkmal.qualifier"]),
            ("obis_marktlokation", &["produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55684Interchange = crate::model::Interchange<
    Pid55684MessageStammdaten,
    Pid55684TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55685MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55685: Rückmeldung/Anfrage Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55685TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, merkmal.code, merkmal.qualifier, produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55685TransaktionStammdaten {
    /// Required entity fields for PID 55685 (Rückmeldung/Anfrage Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "merkmal.code", "merkmal.qualifier", "produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55685Interchange = crate::model::Interchange<
    Pid55685MessageStammdaten,
    Pid55685TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55686MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55686: Änderung Daten der Tranche
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55686TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: merkmal.code, merkmal.qualifier, produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub obis_kennzahl_daten: Option<Vec<ObisKennzahlDatenWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55686TransaktionStammdaten {
    /// Required entity fields for PID 55686 (Änderung Daten der Tranche).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("obis_kennzahl_daten", &["merkmal.code", "merkmal.qualifier", "produktIdentifikation.id", "zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
        ]
    }
}

pub type Pid55686Interchange = crate::model::Interchange<
    Pid55686MessageStammdaten,
    Pid55686TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55687MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55687: Rückmeldung/Anfrage Daten der Tranche
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55687TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    /// Required (Muss). Fields: merkmal.code, merkmal.qualifier, produktIdentifikation.id, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler: Option<Vec<ZaehlerWrapped>>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55687TransaktionStammdaten {
    /// Required entity fields for PID 55687 (Rückmeldung/Anfrage Daten der Tranche).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("tranche", &["codelisteCode", "codepflegeCode", "trancheId"]),
            ("zaehler", &["merkmal.code", "merkmal.qualifier", "produktIdentifikation.id", "zeitscheibe.referenz"]),
        ]
    }
}

pub type Pid55687Interchange = crate::model::Interchange<
    Pid55687MessageStammdaten,
    Pid55687TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55688MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55688: Änderung Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55688TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, merkmal.code, zeitscheibe.referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55688TransaktionStammdaten {
    /// Required entity fields for PID 55688 (Änderung Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "merkmal.code", "zeitscheibe.referenz", "zugeordneterMp"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55688Interchange = crate::model::Interchange<
    Pid55688MessageStammdaten,
    Pid55688TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55689MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55689: Rückmeldung/Anfrage Daten der MaLo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55689TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    /// Required (Muss). Fields: merkmal.code, zeitscheibe.referenz, zugeordneterMp
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub zaehler: Option<Vec<ZaehlerWrapped>>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55689TransaktionStammdaten {
    /// Required entity fields for PID 55689 (Rückmeldung/Anfrage Daten der MaLo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
            ("zaehler", &["merkmal.code", "zeitscheibe.referenz", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55689Interchange = crate::model::Interchange<
    Pid55689MessageStammdaten,
    Pid55689TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55690MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55690: Lokationsbündelstruktur und DB
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55690TransaktionStammdaten {
    /// Required (Muss). Fields: referenz, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub lokationsbuendel_daten: Option<Vec<LokationsbuendelDatenWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, lokationZeitraumId, marktlokationsId, ruhendeMarktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    /// Required (Muss). Fields: referenz.id, referenz.typ, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation_daten: Option<Vec<MarktlokationDatenWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, lokationZeitraumId, messlokationsId, referenz, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub messlokation: Option<Vec<MesslokationWrapped>>,
    /// Required (Muss). Fields: lokationZeitraumId, netzlokationsId, referenz, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub netzlokation: Option<Vec<NetzlokationWrapped>>,
    /// Required (Muss). Fields: ideQualifier, pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    /// Required (Muss). Fields: lokationZeitraumId, referenz, steuerbareRessourceId, zeitscheibe.referenz
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub steuerbare_ressource: Option<Vec<SteuerbareRessourceWrapped>>,
    /// Required (Muss). Fields: lokationZeitraumId, technischeRessourceId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub technische_ressource: Option<Vec<TechnischeRessourceWrapped>>,
    /// Required (Muss). Fields: lokationZeitraumId, trancheId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub tranche: Option<Vec<Tranche>>,
    pub zeitscheibe: Option<Zeitscheibe>,
    /// Required (Muss). Fields: merkmal.code, merkmal.eigenschaft, merkmal.klasse, merkmal.qualifier, zugeordneterMp
    pub zuordnung: Option<Zuordnung>,
}

impl Pid55690TransaktionStammdaten {
    /// Required entity fields for PID 55690 (Lokationsbündelstruktur und DB).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("lokationsbuendel_daten", &["referenz", "zeitscheibe.referenz"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "lokationZeitraumId", "marktlokationsId", "ruhendeMarktlokationsId"]),
            ("marktlokation_daten", &["referenz.id", "referenz.typ", "zeitscheibe.referenz"]),
            ("messlokation", &["codelisteCode", "codepflegeCode", "lokationZeitraumId", "messlokationsId", "referenz", "zeitscheibe.referenz"]),
            ("netzlokation", &["lokationZeitraumId", "netzlokationsId", "referenz", "zeitscheibe.referenz"]),
            ("prozessdaten", &["ideQualifier", "pruefidentifikator", "transaktionsgrund", "vorgangId"]),
            ("steuerbare_ressource", &["lokationZeitraumId", "referenz", "steuerbareRessourceId", "zeitscheibe.referenz"]),
            ("technische_ressource", &["lokationZeitraumId", "technischeRessourceId"]),
            ("tranche", &["lokationZeitraumId", "trancheId"]),
            ("zuordnung", &["merkmal.code", "merkmal.eigenschaft", "merkmal.klasse", "merkmal.qualifier", "zugeordneterMp"]),
        ]
    }
}

pub type Pid55690Interchange = crate::model::Interchange<
    Pid55690MessageStammdaten,
    Pid55690TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55691MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55691: Änderung Paket-ID der Malo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55691TransaktionStammdaten {
    /// Required (Muss). Fields: codelistCode, codepflegeCode, identifikation, partnerrolle
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId, paketId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, transaktionsgrund, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

impl Pid55691TransaktionStammdaten {
    /// Required entity fields for PID 55691 (Änderung Paket-ID der Malo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("geschaeftspartner", &["codelistCode", "codepflegeCode", "identifikation", "partnerrolle"]),
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId", "paketId"]),
            ("prozessdaten", &["pruefidentifikator", "transaktionsgrund", "vorgangId"]),
        ]
    }
}

pub type Pid55691Interchange = crate::model::Interchange<
    Pid55691MessageStammdaten,
    Pid55691TransaktionStammdaten,
>;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55692MessageStammdaten {
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub kontakt: Option<Vec<Kontakt>>,
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_map_or_vec")]
    pub marktteilnehmer: Option<BTreeMap<MarktteilnehmerKey, MarktteilnehmerWrapped>>,
    pub nachricht: Option<Nachricht>,
}

/// PID 55692: Rückmeldung/Anfrage Paket-ID der Malo
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55692TransaktionStammdaten {
    /// Required (Muss). Fields: codelisteCode, codepflegeCode, marktlokationsId
    #[serde(default, deserialize_with = "crate::serde_helpers::deserialize_vec_or_single")]
    pub marktlokation: Option<Vec<MarktlokationWrapped>>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    /// Required (Muss). Fields: pruefidentifikator, pruefschrittCode, transaktionsgrund, transaktionsnummer, vorgangId
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

impl Pid55692TransaktionStammdaten {
    /// Required entity fields for PID 55692 (Rückmeldung/Anfrage Paket-ID der Malo).
    ///
    /// Each entry is `(entity_field, required_bo4e_fields)`.
    pub fn required_fields() -> &'static [(&'static str, &'static [&'static str])] {
        &[
            ("marktlokation", &["codelisteCode", "codepflegeCode", "marktlokationsId"]),
            ("prozessdaten", &["pruefidentifikator", "pruefschrittCode", "transaktionsgrund", "transaktionsnummer", "vorgangId"]),
        ]
    }
}

pub type Pid55692Interchange = crate::model::Interchange<
    Pid55692MessageStammdaten,
    Pid55692TransaktionStammdaten,
>;

