rubo4e 0.11.0

use super::{
    Adresse, Bilanzierungsmethode, Bo4eObject, BoTyp, Energiemenge, Energierichtung, Gasqualitaet,
    Gebiettyp, Geokoordinaten, Geschaeftspartner, Katasteradresse, Kundentyp, Lokationszuordnung,
    Netzebene, Sparte, Verbrauchsart, Zaehlwerk, ZusatzAttribut,
};
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(not(feature = "json"), derive(Eq, Hash))]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "builder", derive(typed_builder::TypedBuilder))]
#[cfg_attr(feature = "validate", derive(garde::Validate))]
#[cfg_attr(feature = "validate", garde(allow_unvalidated))]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
#[cfg_attr(
    all(feature = "validate", feature = "versioned"),
    garde(custom(crate::validation::v202607::validate_marktlokation))
)]
/// Object containing information about a Marktlokation
///
/// > **Note:** [Marktlokation JSON Schema](https://json-schema.app/view/%23?url=https://raw.githubusercontent.com/BO4E/BO4E-Schemas/v202607.1.0/src/bo4e_schemas/bo/Marktlokation.json)
pub struct Marktlokation {
    /// Bilanzierungsgebiet, dem das Netzgebiet zugeordnet ist - im Falle eines Strom Netzes
    #[cfg_attr(feature = "serde", serde(rename = "bilanzierungsgebiet"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    pub bilanzierungsgebiet: Option<String>,
    /// Die Bilanzierungsmethode, RLM oder SLP
    #[cfg_attr(feature = "serde", serde(rename = "bilanzierungsmethode"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    pub bilanzierungsmethode: Option<Bilanzierungsmethode>,
    /// Geschäftspartner, dem diese Marktlokation gehört
    #[cfg_attr(feature = "serde", serde(rename = "endkunde"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    #[cfg_attr(feature = "validate", garde(dive))]
    pub endkunde: Option<Box<Geschaeftspartner>>,
    /// Kennzeichnung, ob Energie eingespeist oder entnommen (ausgespeist) wird
    #[cfg_attr(feature = "serde", serde(rename = "energierichtung"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    pub energierichtung: Option<Energierichtung>,
    /// Die Gasqualität in diesem Netzgebiet. H-Gas oder L-Gas. Im Falle eines Gas-Netzes
    #[cfg_attr(feature = "serde", serde(rename = "gasqualitaet"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    pub gasqualitaet: Option<Gasqualitaet>,
    /// Typ des Netzgebietes, z.B. Verteilnetz
    #[cfg_attr(feature = "serde", serde(rename = "gebietstyp"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    pub gebietstyp: Option<Gebiettyp>,
    /// Alternativ zu einer postalischen Adresse kann hier ein Ort mittels Geokoordinaten angegeben werden
    /// (z.B. zur Identifikation von Sendemasten).
    #[cfg_attr(feature = "serde", serde(rename = "geoadresse"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    #[cfg_attr(feature = "validate", garde(dive))]
    pub geoadresse: Option<Geokoordinaten>,
    /// Codenummer des Grundversorgers, der für diese Marktlokation zuständig ist
    #[cfg_attr(feature = "serde", serde(rename = "grundversorgercodenr"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    #[cfg_attr(feature = "validate", garde(dive))]
    pub grundversorgercodenr: Option<crate::identifiers::MarktpartnerId>,
    /// Eine generische ID, die für eigene Zwecke genutzt werden kann.
    /// Z.B. könnten hier UUIDs aus einer Datenbank stehen oder URLs zu einem Backend-System.
    #[cfg_attr(feature = "serde", serde(rename = "_id"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    pub id: Option<String>,
    /// Alternativ zu einer postalischen Adresse und Geokoordinaten kann hier eine Ortsangabe mittels Gemarkung und
    /// Flurstück erfolgen.
    #[cfg_attr(feature = "serde", serde(rename = "katasterinformation"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    #[cfg_attr(feature = "validate", garde(dive))]
    pub katasterinformation: Option<Katasteradresse>,
    /// Kundengruppen der Marktlokation
    #[cfg_attr(feature = "serde", serde(rename = "kundengruppen"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    pub kundengruppen: Option<Vec<Kundentyp>>,
    /// Die Adresse, an der die Energie-Lieferung oder -Einspeisung erfolgt
    #[cfg_attr(feature = "serde", serde(rename = "lokationsadresse"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    #[cfg_attr(feature = "validate", garde(dive))]
    pub lokationsadresse: Option<Adresse>,
    /// Lokationsbuendel Code, der die Funktion dieses BOs an der Lokationsbuendelstruktur beschreibt.
    #[cfg_attr(feature = "serde", serde(rename = "lokationsbuendelObjektcode"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    pub lokationsbuendel_objektcode: Option<String>,
    /// Lokationszuordnung, um bspw. die zugehörigen Messlokationen anzugeben
    #[cfg_attr(feature = "serde", serde(rename = "lokationszuordnungen"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    #[cfg_attr(feature = "validate", garde(dive))]
    pub lokationszuordnungen: Option<Vec<Box<Lokationszuordnung>>>,
    /// für Gas. Code vom EIC, <https://www.entsog.eu/data/data-portal/codes-list>
    #[cfg_attr(feature = "serde", serde(rename = "marktgebiet"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    #[cfg_attr(feature = "validate", garde(dive))]
    pub marktgebiet: Option<crate::identifiers::EicCode>,
    /// Identifikationsnummer einer Marktlokation, an der Energie entweder verbraucht, oder erzeugt wird.
    #[cfg_attr(feature = "serde", serde(rename = "marktlokationsId"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    #[cfg_attr(feature = "validate", garde(dive))]
    pub marktlokations_id: Option<crate::identifiers::MaloId>,
    /// Codenummer des Netzbetreibers, an dessen Netz diese Marktlokation angeschlossen ist.
    #[cfg_attr(feature = "serde", serde(rename = "netzbetreibercodenr"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    #[cfg_attr(feature = "validate", garde(dive))]
    pub netzbetreibercodenr: Option<crate::identifiers::MarktpartnerId>,
    /// Netzebene, in der der Bezug der Energie erfolgt.
    /// Bei Strom Spannungsebene der Lieferung, bei Gas Druckstufe.
    /// Beispiel Strom: Niederspannung Beispiel Gas: Niederdruck.
    #[cfg_attr(feature = "serde", serde(rename = "netzebene"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    pub netzebene: Option<Netzebene>,
    /// Die ID des Gebietes in der ene't-Datenbank
    #[cfg_attr(feature = "serde", serde(rename = "netzgebietsnr"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    pub netzgebietsnr: Option<String>,
    /// für Strom. Code vom EIC, <https://www.entsoe.eu/data/energy-identification-codes-eic/eic-approved-codes/>
    #[cfg_attr(feature = "serde", serde(rename = "regelzone"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    #[cfg_attr(feature = "validate", garde(dive))]
    pub regelzone: Option<crate::identifiers::EicCode>,
    /// Sparte der Marktlokation, z.B. Gas oder Strom
    #[cfg_attr(feature = "serde", serde(rename = "sparte"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    pub sparte: Option<Sparte>,
    /// BO4E type discriminant — always `BoTyp::Marktlokation` for this struct.
    #[cfg_attr(feature = "serde", serde(rename = "_typ"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(
        feature = "builder",
        builder(default = Some(BoTyp::Marktlokation), setter(skip))
    )]
    pub typ: Option<BoTyp>,
    /// Verbrauchsart der Marktlokation.
    #[cfg_attr(feature = "serde", serde(rename = "verbrauchsart"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    pub verbrauchsart: Option<Verbrauchsart>,
    #[cfg_attr(feature = "serde", serde(rename = "verbrauchsmengen"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    #[cfg_attr(feature = "validate", garde(dive))]
    pub verbrauchsmengen: Option<Vec<Box<Energiemenge>>>,
    /// Version der BO-Struktur aka "fachliche Versionierung"
    #[cfg_attr(feature = "serde", serde(rename = "_version"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(
        feature = "builder",
        builder(default = Some("202607.1.0".to_owned()), setter(into))
    )]
    pub version: Option<String>,
    #[cfg_attr(feature = "serde", serde(rename = "zaehlwerke"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    #[cfg_attr(feature = "validate", garde(dive))]
    pub zaehlwerke: Option<Vec<Zaehlwerk>>,
    #[cfg_attr(
        feature = "serde",
        serde(rename = "zaehlwerkeDerBeteiligtenMarktrolle")
    )]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    #[cfg_attr(feature = "validate", garde(dive))]
    pub zaehlwerke_der_beteiligten_marktrolle: Option<Vec<Zaehlwerk>>,
    #[cfg_attr(feature = "serde", serde(rename = "zusatzAttribute"))]
    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
    #[cfg_attr(feature = "validate", garde(dive))]
    pub zusatz_attribute: Option<Vec<ZusatzAttribut>>,
    /// Unknown JSON fields captured during deserialization for round-trip preservation.
    /// `None` when no unknown fields were present (zero heap allocation).
    #[cfg_attr(feature = "json", serde(flatten))]
    #[cfg_attr(
        feature = "json",
        serde(skip_serializing_if = "crate::json::ext_map_is_empty")
    )]
    #[cfg_attr(not(feature = "json"), serde(skip))]
    #[cfg_attr(feature = "builder", builder(default, setter(skip)))]
    #[doc(hidden)]
    pub _additional: crate::LimitedExtensionMap,
}
impl Default for Marktlokation {
    fn default() -> Self {
        Self {
            bilanzierungsgebiet: Default::default(),
            bilanzierungsmethode: Default::default(),
            endkunde: Default::default(),
            energierichtung: Default::default(),
            gasqualitaet: Default::default(),
            gebietstyp: Default::default(),
            geoadresse: Default::default(),
            grundversorgercodenr: Default::default(),
            id: Default::default(),
            katasterinformation: Default::default(),
            kundengruppen: Default::default(),
            lokationsadresse: Default::default(),
            lokationsbuendel_objektcode: Default::default(),
            lokationszuordnungen: Default::default(),
            marktgebiet: Default::default(),
            marktlokations_id: Default::default(),
            netzbetreibercodenr: Default::default(),
            netzebene: Default::default(),
            netzgebietsnr: Default::default(),
            regelzone: Default::default(),
            sparte: Default::default(),
            typ: Some(BoTyp::Marktlokation),
            verbrauchsart: Default::default(),
            verbrauchsmengen: Default::default(),
            version: Some("202607.1.0".to_owned()),
            zaehlwerke: Default::default(),
            zaehlwerke_der_beteiligten_marktrolle: Default::default(),
            zusatz_attribute: Default::default(),
            _additional: Default::default(),
        }
    }
}
impl Bo4eObject for Marktlokation {
    type BoTyp = BoTyp;
    const BO_TYP: BoTyp = BoTyp::Marktlokation;
    const TYP_WIRE: &'static str = "MARKTLOKATION";
    const SCHEMA_VERSION: &'static str = "202607.1.0";
    const SCHEMA_SERIES: &'static str = "202607";
}
#[cfg(feature = "json")]
impl crate::json::sealed::Sealed for Marktlokation {}
#[cfg(feature = "json")]
impl crate::json::Bo4eJsonExt for Marktlokation {}
#[cfg(feature = "json")]
impl crate::json::Bo4eExtensionData for Marktlokation {
    fn extension_data(&self) -> &indexmap::IndexMap<String, serde_json::Value> {
        self._additional
            .as_map()
            .unwrap_or(&crate::json::extension::EMPTY_EXTENSION_MAP)
    }
    fn has_extension_data(&self) -> bool {
        !self._additional.is_empty()
    }
}
#[cfg(feature = "json")]
impl std::fmt::Display for Marktlokation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match serde_json::to_string(self) {
            Ok(json) => f.write_str(&json),
            Err(e) => write!(f, "<Marktlokation: serialization error: {e}>"),
        }
    }
}
impl crate::Bo4eStrict for Marktlokation {
    fn collect_unknown_enums(&self, path: &str, out: &mut Vec<String>) {
        if let Some(v) = &self.bilanzierungsmethode {
            crate::Bo4eStrict::collect_unknown_enums(
                v,
                &crate::strict::field_path(path, "bilanzierungsmethode"),
                out,
            );
        }
        if let Some(v) = &self.endkunde {
            crate::Bo4eStrict::collect_unknown_enums(
                &**v,
                &crate::strict::field_path(path, "endkunde"),
                out,
            );
        }
        if let Some(v) = &self.energierichtung {
            crate::Bo4eStrict::collect_unknown_enums(
                v,
                &crate::strict::field_path(path, "energierichtung"),
                out,
            );
        }
        if let Some(v) = &self.gasqualitaet {
            crate::Bo4eStrict::collect_unknown_enums(
                v,
                &crate::strict::field_path(path, "gasqualitaet"),
                out,
            );
        }
        if let Some(v) = &self.gebietstyp {
            crate::Bo4eStrict::collect_unknown_enums(
                v,
                &crate::strict::field_path(path, "gebietstyp"),
                out,
            );
        }
        if let Some(v) = &self.geoadresse {
            crate::Bo4eStrict::collect_unknown_enums(
                v,
                &crate::strict::field_path(path, "geoadresse"),
                out,
            );
        }
        if let Some(v) = &self.katasterinformation {
            crate::Bo4eStrict::collect_unknown_enums(
                v,
                &crate::strict::field_path(path, "katasterinformation"),
                out,
            );
        }
        if let Some(items) = &self.kundengruppen {
            let child = crate::strict::field_path(path, "kundengruppen");
            for (i, item) in items.iter().enumerate() {
                crate::Bo4eStrict::collect_unknown_enums(
                    item,
                    &crate::strict::index_path(&child, i),
                    out,
                );
            }
        }
        if let Some(v) = &self.lokationsadresse {
            crate::Bo4eStrict::collect_unknown_enums(
                v,
                &crate::strict::field_path(path, "lokationsadresse"),
                out,
            );
        }
        if let Some(items) = &self.lokationszuordnungen {
            let child = crate::strict::field_path(path, "lokationszuordnungen");
            for (i, item) in items.iter().enumerate() {
                crate::Bo4eStrict::collect_unknown_enums(
                    &**item,
                    &crate::strict::index_path(&child, i),
                    out,
                );
            }
        }
        if let Some(v) = &self.netzebene {
            crate::Bo4eStrict::collect_unknown_enums(
                v,
                &crate::strict::field_path(path, "netzebene"),
                out,
            );
        }
        if let Some(v) = &self.sparte {
            crate::Bo4eStrict::collect_unknown_enums(
                v,
                &crate::strict::field_path(path, "sparte"),
                out,
            );
        }
        if let Some(v) = &self.verbrauchsart {
            crate::Bo4eStrict::collect_unknown_enums(
                v,
                &crate::strict::field_path(path, "verbrauchsart"),
                out,
            );
        }
        if let Some(items) = &self.verbrauchsmengen {
            let child = crate::strict::field_path(path, "verbrauchsmengen");
            for (i, item) in items.iter().enumerate() {
                crate::Bo4eStrict::collect_unknown_enums(
                    &**item,
                    &crate::strict::index_path(&child, i),
                    out,
                );
            }
        }
        if let Some(items) = &self.zaehlwerke {
            let child = crate::strict::field_path(path, "zaehlwerke");
            for (i, item) in items.iter().enumerate() {
                crate::Bo4eStrict::collect_unknown_enums(
                    item,
                    &crate::strict::index_path(&child, i),
                    out,
                );
            }
        }
        if let Some(items) = &self.zaehlwerke_der_beteiligten_marktrolle {
            let child = crate::strict::field_path(path, "zaehlwerkeDerBeteiligtenMarktrolle");
            for (i, item) in items.iter().enumerate() {
                crate::Bo4eStrict::collect_unknown_enums(
                    item,
                    &crate::strict::index_path(&child, i),
                    out,
                );
            }
        }
        if let Some(items) = &self.zusatz_attribute {
            let child = crate::strict::field_path(path, "zusatzAttribute");
            for (i, item) in items.iter().enumerate() {
                crate::Bo4eStrict::collect_unknown_enums(
                    item,
                    &crate::strict::index_path(&child, i),
                    out,
                );
            }
        }
    }
}