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

#![allow(unused_imports)]

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55001TransaktionStammdaten {
    pub ansprechpartner: Option<Ansprechpartner>,
    pub enfg_daten: Option<EnfgDaten>,
    pub geschaeftspartner: Option<GeschaeftspartnerWrapped>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub produktpaket_daten: Option<ProduktpaketDaten>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55002TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55003TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub geschaeftspartner: Option<GeschaeftspartnerWrapped>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55004TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55006TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55007TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55009TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55010TransaktionStammdaten {
    pub ansprechpartner: Option<Ansprechpartner>,
    pub geschaeftspartner: Option<GeschaeftspartnerWrapped>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55012TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55013TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55014TransaktionStammdaten {
    pub ansprechpartner: Option<Ansprechpartner>,
    pub enfg_daten: Option<EnfgDaten>,
    pub geschaeftspartner: Option<GeschaeftspartnerWrapped>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub produktpaket_daten: Option<ProduktpaketDaten>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55016TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55017TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55035TransaktionStammdaten {
    pub geschaeftspartner: Option<GeschaeftspartnerWrapped>,
    pub lokationsbuendel_zuordnung: Option<LokationsbuendelZuordnungWrapped>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_daten: Option<MarktlokationDatenWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub netzlokation_daten: Option<NetzlokationDatenWrapped>,
    pub netznutzungsabrechnungsdaten: Option<NetznutzungsabrechnungsdatenWrapped>,
    pub netznutzungsabrechnungsdaten_mengen: Option<NetznutzungsabrechnungsdatenMengenWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub steuerbare_ressource_daten: Option<SteuerbareRessourceDatenWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub technische_ressource_daten: Option<TechnischeRessourceDatenWrapped>,
    pub technische_ressource_mengen: Option<TechnischeRessourceMengenWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler_daten: Option<ZaehlerDatenWrapped>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55036TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55037TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55038TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55039TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler: Option<ZaehlerWrapped>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55040TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler: Option<ZaehlerWrapped>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55041TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55042TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler: Option<ZaehlerWrapped>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55043TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub lokationsbuendel_daten: Option<LokationsbuendelDatenWrapped>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub mengen_daten: Option<MengenDaten>,
    pub mengen_daten_erw: Option<MengenDatenErw>,
    pub messlokation: Option<MesslokationWrapped>,
    pub messlokation_daten: Option<MesslokationDatenWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    pub obis_marktlokation: Option<ObisMarktlokationWrapped>,
    pub obis_zaehleinrichtung: Option<ObisZaehleinrichtungWrapped>,
    pub produktpaket_daten: Option<ProduktpaketDaten>,
    pub profil_daten: Option<ProfilDaten>,
    pub prozessdaten: Option<Prozessdaten>,
    pub referenzprofil: Option<Referenzprofil>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub steuerbare_ressource_daten: Option<SteuerbareRessourceDatenWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler_daten: Option<ZaehlerDatenWrapped>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55044TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55051TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55052TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55053TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55060TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub lokationsbuendel_zuordnung: Option<LokationsbuendelZuordnungWrapped>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_daten: Option<MarktlokationDatenWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub messlokation_daten: Option<MesslokationDatenWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub netzlokation_daten: Option<NetzlokationDatenWrapped>,
    pub netznutzungsabrechnungsdaten_erw: Option<NetznutzungsabrechnungsdatenErwWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub steuerbare_ressource_daten: Option<SteuerbareRessourceDatenWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler_daten: Option<ZaehlerDatenWrapped>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55062TransaktionStammdaten {
    pub clearing_daten: Option<ClearingDaten>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55063TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55064TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55065TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub profil_daten: Option<ProfilDaten>,
    pub prozessdaten: Option<Prozessdaten>,
    pub referenzprofil: Option<Referenzprofil>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub summenzeitreihen_daten: Option<SummenzeitreihenDaten>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub tranche_daten: Option<TrancheDaten>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55066TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub profil_daten: Option<ProfilDaten>,
    pub prozessdaten: Option<Prozessdaten>,
    pub referenzprofil: Option<Referenzprofil>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub summenzeitreihen_daten: Option<SummenzeitreihenDaten>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub tranche_daten: Option<TrancheDaten>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55067TransaktionStammdaten {
    pub clearing_daten: Option<ClearingDaten>,
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55069TransaktionStammdaten {
    pub clearing_daten: Option<ClearingDaten>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55070TransaktionStammdaten {
    pub clearing_daten: Option<ClearingDaten>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub redispatch_daten: Option<RedispatchDaten>,
    pub redispatch_daten_erw: Option<RedispatchDatenErw>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55071TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55072TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55073TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub profil_daten: Option<ProfilDaten>,
    pub prozessdaten: Option<Prozessdaten>,
    pub referenzprofil: Option<Referenzprofil>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55074TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl_daten: Option<ObisKennzahlDatenWrapped>,
    pub obis_marktlokation: Option<ObisMarktlokationWrapped>,
    pub obis_zaehleinrichtung: Option<ObisZaehleinrichtungWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler_daten: Option<ZaehlerDatenWrapped>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55075TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl_daten: Option<ObisKennzahlDatenWrapped>,
    pub obis_marktlokation: Option<ObisMarktlokationWrapped>,
    pub obis_zaehleinrichtung: Option<ObisZaehleinrichtungWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler_daten: Option<ZaehlerDatenWrapped>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55076TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl_daten: Option<ObisKennzahlDatenWrapped>,
    pub obis_marktlokation: Option<ObisMarktlokationWrapped>,
    pub obis_zaehleinrichtung: Option<ObisZaehleinrichtungWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler_daten: Option<ZaehlerDatenWrapped>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55077TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub produktpaket_daten: Option<ProduktpaketDaten>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55078TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub messlokation_daten: Option<MesslokationDatenWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55080TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55095TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub lokationsbuendel_zuordnung: Option<LokationsbuendelZuordnungWrapped>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_daten: Option<MarktlokationDatenWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub netzlokation_daten: Option<NetzlokationDatenWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub steuerbare_ressource_daten: Option<SteuerbareRessourceDatenWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub technische_ressource_daten: Option<TechnischeRessourceDatenWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler_daten: Option<ZaehlerDatenWrapped>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55109TransaktionStammdaten {
    pub ansprechpartner: Option<Ansprechpartner>,
    pub enfg_daten: Option<EnfgDaten>,
    pub geschaeftspartner: Option<GeschaeftspartnerWrapped>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55110TransaktionStammdaten {
    pub ansprechpartner: Option<Ansprechpartner>,
    pub geschaeftspartner: Option<GeschaeftspartnerWrapped>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55126TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub profil_daten: Option<ProfilDaten>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55136TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55137TransaktionStammdaten {
    pub enfg_daten: Option<EnfgDaten>,
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55156TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub profil_daten: Option<ProfilDaten>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55168TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub lokationsbuendel_daten: Option<LokationsbuendelDatenWrapped>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub mengen_daten: Option<MengenDaten>,
    pub mengen_daten_erw: Option<MengenDatenErw>,
    pub messlokation: Option<MesslokationWrapped>,
    pub messlokation_daten: Option<MesslokationDatenWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    pub obis_marktlokation: Option<ObisMarktlokationWrapped>,
    pub obis_zaehleinrichtung: Option<ObisZaehleinrichtungWrapped>,
    pub produktpaket_daten: Option<ProduktpaketDaten>,
    pub profil_daten: Option<ProfilDaten>,
    pub prozessdaten: Option<Prozessdaten>,
    pub referenzprofil: Option<Referenzprofil>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub steuerbare_ressource_daten: Option<SteuerbareRessourceDatenWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler_daten: Option<ZaehlerDatenWrapped>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55169TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub lokationsbuendel_daten: Option<LokationsbuendelDatenWrapped>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub mengen_daten: Option<MengenDaten>,
    pub mengen_daten_erw: Option<MengenDatenErw>,
    pub messlokation: Option<MesslokationWrapped>,
    pub messlokation_daten: Option<MesslokationDatenWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    pub obis_marktlokation: Option<ObisMarktlokationWrapped>,
    pub obis_zaehleinrichtung: Option<ObisZaehleinrichtungWrapped>,
    pub produktpaket_daten: Option<ProduktpaketDaten>,
    pub profil_daten: Option<ProfilDaten>,
    pub prozessdaten: Option<Prozessdaten>,
    pub referenzprofil: Option<Referenzprofil>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub steuerbare_ressource_daten: Option<SteuerbareRessourceDatenWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler_daten: Option<ZaehlerDatenWrapped>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55170TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55173TransaktionStammdaten {
    pub lokationsbuendel_daten: Option<LokationsbuendelDatenWrapped>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55175TransaktionStammdaten {
    pub lokationsbuendel_daten: Option<LokationsbuendelDatenWrapped>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55177TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_daten: Option<MarktlokationDatenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55180TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55194TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler: Option<ZaehlerWrapped>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55195TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl_daten: Option<ObisKennzahlDatenWrapped>,
    pub obis_marktlokation: Option<ObisMarktlokationWrapped>,
    pub profil: Option<Profil>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub summenzeitreihen_daten: Option<SummenzeitreihenDaten>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub tranche_daten: Option<TrancheDaten>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55196TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl_daten: Option<ObisKennzahlDatenWrapped>,
    pub obis_marktlokation: Option<ObisMarktlokationWrapped>,
    pub profil: Option<Profil>,
    pub prozessdaten: Option<Prozessdaten>,
    pub seq_daten_z29: Option<SeqDatenZ29>,
    pub seq_daten_z29_mengen: Option<SeqDatenZ29Mengen>,
    pub seq_daten_z30: Option<SeqDatenZ30>,
    pub seq_daten_z31: Option<SeqDatenZ31>,
    pub seq_daten_z32: Option<SeqDatenZ32>,
    pub seq_daten_z33: Option<SeqDatenZ33>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub summenzeitreihen_daten: Option<SummenzeitreihenDaten>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub tranche_daten: Option<TrancheDaten>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55197TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub redispatch_daten: Option<RedispatchDaten>,
    pub redispatch_daten_erw: Option<RedispatchDatenErw>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55198TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55199TransaktionStammdaten {
    pub clearing_daten: Option<ClearingDaten>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55200TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55201TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub summenzeitreihen_daten: Option<SummenzeitreihenDaten>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub tranche_daten: Option<TrancheDaten>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55202TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub summenzeitreihen_daten: Option<SummenzeitreihenDaten>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub tranche_daten: Option<TrancheDaten>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55203TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub redispatch_daten: Option<RedispatchDaten>,
    pub redispatch_daten_erw: Option<RedispatchDatenErw>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55204TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55205TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub redispatch_daten: Option<RedispatchDaten>,
    pub redispatch_daten_erw: Option<RedispatchDatenErw>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55206TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55207TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55208TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55209TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub redispatch_daten: Option<RedispatchDaten>,
    pub redispatch_daten_erw: Option<RedispatchDatenErw>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55210TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55211TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub redispatch_daten: Option<RedispatchDaten>,
    pub redispatch_daten_erw: Option<RedispatchDatenErw>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55212TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55213TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55214TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55218TransaktionStammdaten {
    pub abrechnungsdaten: Option<AbrechnungsdatenWrapped>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub netznutzungsabrechnungsdaten: Option<NetznutzungsabrechnungsdatenWrapped>,
    pub netznutzungsabrechnungsdaten_mengen: Option<NetznutzungsabrechnungsdatenMengenWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55220TransaktionStammdaten {
    pub abrechnungsdaten: Option<AbrechnungsdatenWrapped>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55223TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitreihen_daten47: Option<ZeitreihenDaten47>,
    pub zeitreihen_daten47_mengen: Option<ZeitreihenDaten47Mengen>,
    pub zeitreihen_daten48: Option<ZeitreihenDaten48>,
    pub zeitreihen_daten48_mengen: Option<ZeitreihenDaten48Mengen>,
    pub zeitreihen_daten49: Option<ZeitreihenDaten49>,
    pub zeitreihen_daten49_mengen: Option<ZeitreihenDaten49Mengen>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55224TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler: Option<ZaehlerWrapped>,
    pub zaehler_mengen: Option<ZaehlerMengenWrapped>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55225TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55227TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55230TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55232TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55235TransaktionStammdaten {
    pub clearing_daten: Option<ClearingDaten>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55236TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55237TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55238TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55239TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_marktlokation: Option<ObisMarktlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55240TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55241TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55242TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55243TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55553TransaktionStammdaten {
    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>,
    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>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55555TransaktionStammdaten {
    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>,
    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>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55557TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler: Option<ZaehlerWrapped>,
    pub zaehler_mengen: Option<ZaehlerMengenWrapped>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55559TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55600TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub produktpaket_daten: Option<ProduktpaketDaten>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler: Option<ZaehlerWrapped>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55601TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub produktpaket_daten: Option<ProduktpaketDaten>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler: Option<ZaehlerWrapped>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55602TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55603TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub messlokation_daten: Option<MesslokationDatenWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55604TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55605TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55607TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub messlokation_daten: Option<MesslokationDatenWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55608TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub produktpaket_daten: Option<ProduktpaketDaten>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55609TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55611TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55613TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub profil: Option<Profil>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55614TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler: Option<ZaehlerWrapped>,
    pub zaehler_daten: Option<ZaehlerDatenWrapped>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55615TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55616TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl_nutzung: Option<ObisKennzahlNutzungWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub technische_ressource_mengen: Option<TechnischeRessourceMengenWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55619TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55620TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub messlokation_daten: Option<MesslokationDatenWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55621TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55622TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl_nutzung: Option<ObisKennzahlNutzungWrapped>,
    pub produktpaket: Option<ProduktpaketWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub technische_ressource_mengen: Option<TechnischeRessourceMengenWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55626TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55627TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55628TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub profil_daten: Option<ProfilDaten>,
    pub prozessdaten: Option<Prozessdaten>,
    pub referenzprofil: Option<Referenzprofil>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55629TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55632TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55633TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55634TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler_daten: Option<ZaehlerDatenWrapped>,
    pub zaehler_mengen: Option<ZaehlerMengenWrapped>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55635TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55636TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55638TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55639TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    pub produktpaket: Option<ProduktpaketWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55640TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    pub produktpaket: Option<ProduktpaketWrapped>,
    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>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub steuerbare_ressource_daten: Option<SteuerbareRessourceDatenWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[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>,
    pub obis_kennzahl_daten: Option<ObisKennzahlDatenWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55643TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler_daten: Option<ZaehlerDatenWrapped>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55644TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_daten: Option<MarktlokationDatenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55645TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_daten: Option<MarktlokationDatenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub steuerbare_ressource_daten: Option<SteuerbareRessourceDatenWrapped>,
    pub steuerbare_ressource_produkt_daten: Option<SteuerbareRessourceProduktDatenWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[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>,
    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>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55648TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler_daten: Option<ZaehlerDatenWrapped>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55649TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    pub produktpaket: Option<ProduktpaketWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55650TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    pub produktpaket: Option<ProduktpaketWrapped>,
    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>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub steuerbare_ressource_daten: Option<SteuerbareRessourceDatenWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[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>,
    pub obis_kennzahl_daten: Option<ObisKennzahlDatenWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55653TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler_daten: Option<ZaehlerDatenWrapped>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55654TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    pub produktpaket: Option<ProduktpaketWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55655TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_obis_daten: Option<MarktlokationObisDatenWrapped>,
    pub marktlokation_produkt_daten: Option<MarktlokationProduktDatenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    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>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub steuerbare_ressource_daten: Option<SteuerbareRessourceDatenWrapped>,
    pub steuerbare_ressource_produkt_daten: Option<SteuerbareRessourceProduktDatenWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[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>,
    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>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55658TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler_daten: Option<ZaehlerDatenWrapped>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55659TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    pub produktpaket: Option<ProduktpaketWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55660TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_marktlokation: Option<ObisMarktlokationWrapped>,
    pub produktpaket: Option<ProduktpaketWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[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>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub steuerbare_ressource_daten: Option<SteuerbareRessourceDatenWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[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>,
    pub obis_kennzahl_daten: Option<ObisKennzahlDatenWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55663TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_zaehleinrichtung: Option<ObisZaehleinrichtungWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler_daten: Option<ZaehlerDatenWrapped>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55664TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_daten: Option<MarktlokationDatenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55665TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_daten: Option<MarktlokationDatenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55666TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_daten: Option<MarktlokationDatenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[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>,
    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>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55669TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_daten: Option<MarktlokationDatenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub technische_ressource_daten: Option<TechnischeRessourceDatenWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55670TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55671TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    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>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55672TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_mengen: Option<MarktlokationMengenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub profil_daten: Option<ProfilDaten>,
    pub prozessdaten: Option<Prozessdaten>,
    pub referenzprofil: Option<Referenzprofil>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55673TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zaehler_daten: Option<ZaehlerDatenWrapped>,
    pub zaehler_mengen: Option<ZaehlerMengenWrapped>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55674TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55675TransaktionStammdaten {
    pub freitext: Option<Freitext>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    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>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55684TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub obis_kennzahl: Option<ObisKennzahlWrapped>,
    pub obis_marktlokation: Option<ObisMarktlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55685TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[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>,
    pub obis_kennzahl_daten: Option<ObisKennzahlDatenWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[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>,
    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>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55688TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55689TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    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>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55690TransaktionStammdaten {
    pub lokationsbuendel_daten: Option<LokationsbuendelDatenWrapped>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub marktlokation_daten: Option<MarktlokationDatenWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
    pub zuordnung: Option<Zuordnung>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55691TransaktionStammdaten {
    pub geschaeftspartner: Option<Vec<GeschaeftspartnerWrapped>>,
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
    pub zeitscheibe: Option<Zeitscheibe>,
}

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

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

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pid55692TransaktionStammdaten {
    pub marktlokation: Option<MarktlokationWrapped>,
    pub messlokation: Option<MesslokationWrapped>,
    pub netzlokation: Option<NetzlokationWrapped>,
    pub prozessdaten: Option<Prozessdaten>,
    pub steuerbare_ressource: Option<SteuerbareRessourceWrapped>,
    pub technische_ressource: Option<TechnischeRessourceWrapped>,
    pub tranche: Option<Tranche>,
}

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