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

#![allow(unused_imports)]

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AbrechnungsdatenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Marktlokation>,
    pub abrechnungsdaten_edifact: Option<crate::generated::companions::AbrechnungsdatenEdifact>,
}

impl AbrechnungsdatenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Marktlokation) -> Self {
        Self { core: Some(core), abrechnungsdaten_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Ansprechpartner {
    pub anrede: Option<String>,
    pub nachname: Option<String>,
    pub vorname: Option<String>,
    pub ansprechpartner_edifact: Option<crate::generated::companions::AnsprechpartnerEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ClearingDaten {
    pub clearing_daten_edifact: Option<crate::generated::companions::ClearingDatenEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EnfgDaten {
    pub datenqualitaet: Option<String>,
    pub enfg_daten_edifact: Option<crate::generated::companions::EnfgDatenEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Freitext {
    pub freitext_edifact: Option<crate::generated::companions::FreitextEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GeschaeftspartnerWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Geschaeftspartner>,
    pub geschaeftspartner_edifact: Option<crate::generated::companions::GeschaeftspartnerEdifact>,
}

impl GeschaeftspartnerWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Geschaeftspartner) -> Self {
        Self { core: Some(core), geschaeftspartner_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Kontakt {
    pub kommunikationsart: Option<String>,
    pub kommunikationsnummer: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LokationsbuendelDatenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Lokationszuordnung>,
    pub lokationsbuendel_daten_edifact: Option<crate::generated::companions::LokationsbuendelDatenEdifact>,
}

impl LokationsbuendelDatenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Lokationszuordnung) -> Self {
        Self { core: Some(core), lokationsbuendel_daten_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LokationsbuendelStruktur {
    pub fortlaufende_nummer: Option<String>,
    pub lokationsbuendel_struktur_id: Option<String>,
    pub lokationsbuendel_struktur_edifact: Option<crate::generated::companions::LokationsbuendelStrukturEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LokationsbuendelZuordnungWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Lokationszuordnung>,
    pub lokationsbuendel_zuordnung_edifact: Option<crate::generated::companions::LokationsbuendelZuordnungEdifact>,
}

impl LokationsbuendelZuordnungWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Lokationszuordnung) -> Self {
        Self { core: Some(core), lokationsbuendel_zuordnung_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarktlokationWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Marktlokation>,
    pub marktlokation_edifact: Option<crate::generated::companions::MarktlokationEdifact>,
}

impl MarktlokationWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Marktlokation) -> Self {
        Self { core: Some(core), marktlokation_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarktlokationDatenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Marktlokation>,
    pub marktlokation_daten_edifact: Option<crate::generated::companions::MarktlokationDatenEdifact>,
}

impl MarktlokationDatenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Marktlokation) -> Self {
        Self { core: Some(core), marktlokation_daten_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarktlokationMengenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Marktlokation>,
    pub marktlokation_mengen_edifact: Option<crate::generated::companions::MarktlokationMengenEdifact>,
}

impl MarktlokationMengenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Marktlokation) -> Self {
        Self { core: Some(core), marktlokation_mengen_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarktlokationObisDatenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Marktlokation>,
    pub marktlokation_obis_daten_edifact: Option<crate::generated::companions::MarktlokationObisDatenEdifact>,
}

impl MarktlokationObisDatenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Marktlokation) -> Self {
        Self { core: Some(core), marktlokation_obis_daten_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarktlokationProduktDatenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Marktlokation>,
    pub marktlokation_produkt_daten_edifact: Option<crate::generated::companions::MarktlokationProduktDatenEdifact>,
}

impl MarktlokationProduktDatenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Marktlokation) -> Self {
        Self { core: Some(core), marktlokation_produkt_daten_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarktteilnehmerWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Marktteilnehmer>,
}

impl MarktteilnehmerWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Marktteilnehmer) -> Self {
        Self { core: Some(core) }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Meldepunkt {
    pub meldepunkt_id: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MengenDaten {
    pub mengen_daten_edifact: Option<crate::generated::companions::MengenDatenEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MengenDatenErw {
    pub mengen_daten_erw_edifact: Option<crate::generated::companions::MengenDatenErwEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MesslokationWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Messlokation>,
    pub messlokation_edifact: Option<crate::generated::companions::MesslokationEdifact>,
}

impl MesslokationWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Messlokation) -> Self {
        Self { core: Some(core), messlokation_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MesslokationDatenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Messlokation>,
    pub messlokation_daten_edifact: Option<crate::generated::companions::MesslokationDatenEdifact>,
}

impl MesslokationDatenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Messlokation) -> Self {
        Self { core: Some(core), messlokation_daten_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Nachricht {
    pub erstellungsdatum: Option<String>,
    pub nachrichtennummer: Option<String>,
    pub nachrichtentyp: Option<String>,
    pub referenz_version: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NetzlokationWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Netzlokation>,
    pub netzlokation_edifact: Option<crate::generated::companions::NetzlokationEdifact>,
}

impl NetzlokationWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Netzlokation) -> Self {
        Self { core: Some(core), netzlokation_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NetzlokationDatenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Netzlokation>,
    pub netzlokation_daten_edifact: Option<crate::generated::companions::NetzlokationDatenEdifact>,
}

impl NetzlokationDatenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Netzlokation) -> Self {
        Self { core: Some(core), netzlokation_daten_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NetznutzungsabrechnungsdatenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Marktlokation>,
    pub netznutzungsabrechnungsdaten_edifact: Option<crate::generated::companions::NetznutzungsabrechnungsdatenEdifact>,
}

impl NetznutzungsabrechnungsdatenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Marktlokation) -> Self {
        Self { core: Some(core), netznutzungsabrechnungsdaten_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NetznutzungsabrechnungsdatenErwWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Marktlokation>,
    pub netznutzungsabrechnungsdaten_erw_edifact: Option<crate::generated::companions::NetznutzungsabrechnungsdatenErwEdifact>,
}

impl NetznutzungsabrechnungsdatenErwWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Marktlokation) -> Self {
        Self { core: Some(core), netznutzungsabrechnungsdaten_erw_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NetznutzungsabrechnungsdatenMengenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Marktlokation>,
    pub netznutzungsabrechnungsdaten_mengen_edifact: Option<crate::generated::companions::NetznutzungsabrechnungsdatenMengenEdifact>,
}

impl NetznutzungsabrechnungsdatenMengenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Marktlokation) -> Self {
        Self { core: Some(core), netznutzungsabrechnungsdaten_mengen_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ObisKennzahlWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Zaehlwerk>,
    pub obis_kennzahl_edifact: Option<crate::generated::companions::ObisKennzahlEdifact>,
}

impl ObisKennzahlWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Zaehlwerk) -> Self {
        Self { core: Some(core), obis_kennzahl_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ObisKennzahlDatenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Zaehlwerk>,
    pub obis_kennzahl_daten_edifact: Option<crate::generated::companions::ObisKennzahlDatenEdifact>,
}

impl ObisKennzahlDatenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Zaehlwerk) -> Self {
        Self { core: Some(core), obis_kennzahl_daten_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ObisKennzahlNutzungWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Zaehlwerk>,
    pub obis_kennzahl_nutzung_edifact: Option<crate::generated::companions::ObisKennzahlNutzungEdifact>,
}

impl ObisKennzahlNutzungWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Zaehlwerk) -> Self {
        Self { core: Some(core), obis_kennzahl_nutzung_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ObisKennzahlNutzungZuordnung {
    pub zuordnung_edifact: Option<crate::generated::companions::ZuordnungEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ObisKennzahlZuordnungWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Zaehlwerk>,
    pub obis_kennzahl_zuordnung_edifact: Option<crate::generated::companions::ObisKennzahlZuordnungEdifact>,
}

impl ObisKennzahlZuordnungWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Zaehlwerk) -> Self {
        Self { core: Some(core), obis_kennzahl_zuordnung_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ObisMarktlokationWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Zaehlwerk>,
    pub obis_marktlokation_edifact: Option<crate::generated::companions::ObisMarktlokationEdifact>,
}

impl ObisMarktlokationWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Zaehlwerk) -> Self {
        Self { core: Some(core), obis_marktlokation_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ObisZaehleinrichtungWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Zaehlwerk>,
    pub obis_zaehleinrichtung_edifact: Option<crate::generated::companions::ObisZaehleinrichtungEdifact>,
}

impl ObisZaehleinrichtungWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Zaehlwerk) -> Self {
        Self { core: Some(core), obis_zaehleinrichtung_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ProduktpaketWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Marktlokation>,
    pub produktpaket_edifact: Option<crate::generated::companions::ProduktpaketEdifact>,
}

impl ProduktpaketWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Marktlokation) -> Self {
        Self { core: Some(core), produktpaket_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ProduktpaketDaten {
    pub produktpaket_daten_edifact: Option<crate::generated::companions::ProduktpaketDatenEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ProduktpaketZuordnung {
    pub produktpaket_zuordnung_edifact: Option<crate::generated::companions::ProduktpaketZuordnungEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Profil {
    pub profil_edifact: Option<crate::generated::companions::ProfilEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ProfilDaten {
    pub datenqualitaet: Option<String>,
    pub datenqualitaet2: Option<String>,
    pub profil_daten_edifact: Option<crate::generated::companions::ProfilDatenEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ProzessdatenZeitscheibe {
    pub referenz: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Prozessdaten {
    pub abrechnungsperiode: Option<String>,
    pub aenderung_bis: Option<String>,
    pub aenderung_von: Option<String>,
    pub annahmedatum: Option<String>,
    pub antwort_bearbeitungsstand: Option<String>,
    pub antwort_bearbeitungsstand2: Option<String>,
    pub antwort_kategorie: Option<String>,
    pub antwort_status: Option<String>,
    pub antwort_status_code: Option<String>,
    pub bearbeitungsstand: Option<String>,
    pub beginndatum: Option<String>,
    pub belieferungsende: Option<String>,
    pub bestaetigter_kuendigungstermin_kunde: Option<String>,
    pub codepflege_stelle: Option<String>,
    pub codepflege_stelle2: Option<String>,
    pub datum_naechste_bearbeitung: Option<String>,
    pub datum_z22: Option<String>,
    pub datum_z50: Option<String>,
    pub datum_z51: Option<String>,
    pub ebd_codepflege: Option<String>,
    pub ebd_nummer: Option<String>,
    pub ebd_nummer2: Option<String>,
    pub ebd_verantwortliche_stelle: Option<String>,
    pub ebd_verantwortliche_stelle2: Option<String>,
    pub einzugs_datum: Option<String>,
    pub freitext: Option<String>,
    pub freitext_referenz: Option<String>,
    pub geplanter_lieferbeginn: Option<String>,
    pub geplantes_paket: Option<String>,
    pub gueltig_ab: Option<String>,
    pub gueltig_bis: Option<String>,
    pub ide_qualifier: Option<String>,
    pub kuendigungsfrist: Option<String>,
    pub kuendigungstermin: Option<String>,
    pub pruefidentifikator: Option<String>,
    pub pruefschritt_code: Option<String>,
    pub pruefschritt_code2: Option<String>,
    pub referenz: Option<String>,
    pub referenz_bestellungsantwort: Option<String>,
    pub referenz_vorgangs_id: Option<String>,
    pub status_code: Option<String>,
    pub status_z35: Option<String>,
    pub status_z35_bearbeitungsstand: Option<String>,
    pub status_z35_codepflegestelle2: Option<String>,
    pub status_z35_ebdnummer2: Option<String>,
    pub status_z35_transaktionsgrund2: Option<String>,
    pub status_z35_zeitraumid2: Option<String>,
    pub transaktions_referenz: Option<String>,
    pub transaktionsgrund: Option<String>,
    pub transaktionsgrund_detail: Option<String>,
    pub transaktionsgrund_ergaenzung: Option<String>,
    pub transaktionsgrund_ergaenzung_befristete_anmeldung: Option<String>,
    pub transaktionsgrund_lieferende: Option<String>,
    pub transaktionsgrund_referenz: Option<String>,
    pub transaktionsnummer: Option<String>,
    pub transaktionsnummer2: Option<String>,
    pub vorgang_id: Option<String>,
    pub vorgangsnummer: Option<String>,
    pub zeitraum_id2: Option<String>,
    pub zeitraum_id_aenderungsmeldung: Option<String>,
    pub zeitraum_id_ref: Option<String>,
    pub zeitscheibe: Option<ProzessdatenZeitscheibe>,
    pub prozessdaten_edifact: Option<crate::generated::companions::ProzessdatenEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RedispatchDaten {
    pub redispatch_daten_edifact: Option<crate::generated::companions::RedispatchDatenEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RedispatchDatenErw {
    pub redispatch_daten_erw_edifact: Option<crate::generated::companions::RedispatchDatenErwEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Referenzprofil {
    pub referenzprofil_edifact: Option<crate::generated::companions::ReferenzprofilEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SeqDatenZ29 {
    pub seq_daten_z29_edifact: Option<crate::generated::companions::SeqDatenZ29Edifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SeqDatenZ29Mengen {
    pub seq_daten_z29_mengen_edifact: Option<crate::generated::companions::SeqDatenZ29MengenEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SeqDatenZ30 {
    pub seq_daten_z30_edifact: Option<crate::generated::companions::SeqDatenZ30Edifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SeqDatenZ31 {
    pub seq_daten_z31_edifact: Option<crate::generated::companions::SeqDatenZ31Edifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SeqDatenZ32 {
    pub seq_daten_z32_edifact: Option<crate::generated::companions::SeqDatenZ32Edifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SeqDatenZ33 {
    pub seq_daten_z33_edifact: Option<crate::generated::companions::SeqDatenZ33Edifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SteuerbareRessourceWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::SteuerbareRessource>,
    pub steuerbare_ressource_edifact: Option<crate::generated::companions::SteuerbareRessourceEdifact>,
}

impl SteuerbareRessourceWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::SteuerbareRessource) -> Self {
        Self { core: Some(core), steuerbare_ressource_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SteuerbareRessourceDatenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::SteuerbareRessource>,
    pub steuerbare_ressource_daten_edifact: Option<crate::generated::companions::SteuerbareRessourceDatenEdifact>,
}

impl SteuerbareRessourceDatenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::SteuerbareRessource) -> Self {
        Self { core: Some(core), steuerbare_ressource_daten_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SteuerbareRessourceProduktDatenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::SteuerbareRessource>,
    pub steuerbare_ressource_produkt_daten_edifact: Option<crate::generated::companions::SteuerbareRessourceProduktDatenEdifact>,
}

impl SteuerbareRessourceProduktDatenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::SteuerbareRessource) -> Self {
        Self { core: Some(core), steuerbare_ressource_produkt_daten_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SummenzeitreihenDaten {
    pub summenzeitreihen_daten_edifact: Option<crate::generated::companions::SummenzeitreihenDatenEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TechnischeRessourceWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::TechnischeRessource>,
    pub technische_ressource_edifact: Option<crate::generated::companions::TechnischeRessourceEdifact>,
}

impl TechnischeRessourceWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::TechnischeRessource) -> Self {
        Self { core: Some(core), technische_ressource_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TechnischeRessourceDatenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::TechnischeRessource>,
    pub technische_ressource_daten_edifact: Option<crate::generated::companions::TechnischeRessourceDatenEdifact>,
}

impl TechnischeRessourceDatenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::TechnischeRessource) -> Self {
        Self { core: Some(core), technische_ressource_daten_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TechnischeRessourceMengenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::TechnischeRessource>,
    pub technische_ressource_mengen_edifact: Option<crate::generated::companions::TechnischeRessourceMengenEdifact>,
}

impl TechnischeRessourceMengenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::TechnischeRessource) -> Self {
        Self { core: Some(core), technische_ressource_mengen_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TechnischeRessourceZuordnung {
    pub technische_ressource_zuordnung_edifact: Option<crate::generated::companions::TechnischeRessourceZuordnungEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TermindatenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Marktlokation>,
    pub termindaten_edifact: Option<crate::generated::companions::TermindatenEdifact>,
}

impl TermindatenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Marktlokation) -> Self {
        Self { core: Some(core), termindaten_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Tranche {
    pub identifikation: Option<String>,
    pub lokation_zeitraum_id: Option<String>,
    pub tranche_id: Option<String>,
    pub tranche_edifact: Option<crate::generated::companions::TrancheEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TrancheDaten {
    pub tranche_daten_edifact: Option<crate::generated::companions::TrancheDatenEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZaehlerWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Zaehler>,
    pub zaehler_edifact: Option<crate::generated::companions::ZaehlerEdifact>,
}

impl ZaehlerWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Zaehler) -> Self {
        Self { core: Some(core), zaehler_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZaehlerDatenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Zaehler>,
    pub zaehler_daten_edifact: Option<crate::generated::companions::ZaehlerDatenEdifact>,
}

impl ZaehlerDatenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Zaehler) -> Self {
        Self { core: Some(core), zaehler_daten_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZaehlerMengenWrapped {
    #[serde(flatten)]
    pub core: Option<bo4e_german::Zaehler>,
    pub zaehler_mengen_edifact: Option<crate::generated::companions::ZaehlerMengenEdifact>,
}

impl ZaehlerMengenWrapped {
    /// Create a wrapped entity from a core BO4E type, with companion fields defaulted.
    pub fn with_core(core: bo4e_german::Zaehler) -> Self {
        Self { core: Some(core), zaehler_mengen_edifact: None }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZeitreihenDaten47 {
    pub zeitreihen_daten47_edifact: Option<crate::generated::companions::ZeitreihenDaten47Edifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZeitreihenDaten47Mengen {
    pub zeitreihen_daten47_mengen_edifact: Option<crate::generated::companions::ZeitreihenDaten47MengenEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZeitreihenDaten48 {
    pub zeitreihen_daten48_edifact: Option<crate::generated::companions::ZeitreihenDaten48Edifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZeitreihenDaten48Mengen {
    pub zeitreihen_daten48_mengen_edifact: Option<crate::generated::companions::ZeitreihenDaten48MengenEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZeitreihenDaten49 {
    pub zeitreihen_daten49_edifact: Option<crate::generated::companions::ZeitreihenDaten49Edifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZeitreihenDaten49Mengen {
    pub zeitreihen_daten49_mengen_edifact: Option<crate::generated::companions::ZeitreihenDaten49MengenEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZeitscheibeZeitscheibe {
    pub referenz: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Zeitscheibe {
    pub zeitscheibe: Option<ZeitscheibeZeitscheibe>,
    pub zeitscheibe_edifact: Option<crate::generated::companions::ZeitscheibeEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Zuordnung {
    pub zuordnung_edifact: Option<crate::generated::companions::ZuordnungEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZuordnungGateway {
    pub zuordnung_edifact: Option<crate::generated::companions::ZuordnungEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZuordnungMesslokation {
    pub zuordnung_edifact: Option<crate::generated::companions::ZuordnungEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZuordnungObis {
    pub zuordnung_edifact: Option<crate::generated::companions::ZuordnungEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZuordnungProdukt {
    pub zuordnung_edifact: Option<crate::generated::companions::ZuordnungEdifact>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZuordnungWandler {
    pub zuordnung_edifact: Option<crate::generated::companions::ZuordnungEdifact>,
}

