Klassen impl

shared/src/commonMain/kotlin/at/mocode/shared/enums/Enums.kt

@@ -2,6 +2,36 @@ package at.mocode.shared.enums
 
 import kotlinx.serialization.Serializable
 
+@Serializable
+enum class RegelwerkTypE { OETO, FEI, SONSTIGE }
+
+@Serializable
+enum class DatenQuelleE { OEPS_ZNS, MANUELL }
+
+@Serializable
+enum class VerbandE { OEPS, FEI, SONSTIGE }
+
+@Serializable
+enum class LizenzKategorieE { REITERLIZENZ, FAHRERLIZENZ, STARTKARTE }
+
+@Serializable
+enum class SportfachStammdatenTypE { DRESSURAUFGABE, WERTUNGSVERFAHREN_SPRINGEN, WERTUNGSVERFAHREN_DRESSUR, BEWERBSKLASSE, BEWERBSKATEGORIE_OETO }
+
+@Serializable
+enum class PruefungsViereckE { VIERECK_20X40, VIERECK_20X60 }
+
+@Serializable
+enum class RichtverfahrenModusE { GM, GT }
+
+@Serializable
+enum class GeschlechtE { M, W }
+
+@Serializable
+enum class PferdeGeschlechtE {
+    HENGST, STUTE, WALLACH, UNBEKANNT
+}
+
+
 @Serializable
 enum class VeranstalterTyp { VEREIN, FIRMA, PRIVATPERSON, SONSTIGE, UNBEKANNT }
 @Serializable
@@ -9,7 +39,7 @@ enum class PlatzTyp { AUSTRAGUNG, VORBEREITUNG, LONGIEREN, SONSTIGES }
 @Serializable
 enum class NennungsArt { OEPS_ZNS, EIGENES_ONLINE, DIREKT_VERANSTALTER_EMAIL, DIREKT_VERANSTALTER_TELEFON, DIREKT_VERANSTALTER_WHATSAPP, SONSTIGE }
 @Serializable
-enum class Sparte { DRESSUR, SPRINGEN, VIELSEITIGKEIT, FAHREN, VOLTIGIEREN, WESTERN, DISTANZ, ISLAND, PFERDESPORT_SPIEL, BASIS, KOMBINIERT, SONSTIGES }
+enum class SparteE { DRESSUR, SPRINGEN, VIELSEITIGKEIT, FAHREN, VOLTIGIEREN, WESTERN, DISTANZ, ISLAND, PFERDESPORT_SPIEL, BASIS, KOMBINIERT, SONSTIGES }
 @Serializable
 enum class BewerbStatus { GEPLANT, OFFEN_FUER_NENNUNG, GESCHLOSSEN_FUER_NENNUNG, LAEUFT, ABGESCHLOSSEN, ABGESAGT }
 @Serializable

shared/src/commonMain/kotlin/at/mocode/shared/model/Bewerb.kt

@@ -1,7 +1,7 @@
 package at.mocode.shared.model
 
 import at.mocode.shared.enums.BeginnzeitTyp
-import at.mocode.shared.enums.Sparte
+import at.mocode.shared.enums.SparteE
 import at.mocode.shared.serializers.*
 import com.benasher44.uuid.Uuid
 import com.benasher44.uuid.uuid4
@@ -24,7 +24,7 @@ data class Bewerb(
     var nummer: String,                     // Offizielle Nummer aus Ausschreibung, z.B. "12"
     var bezeichnungOffiziell: String,       // z.B. "Dressurprüfung Kl. L", "Standardspringprüfung 115cm"
     var internerName: String?,              // Für Listen, falls abweichend/kürzer
-    var sparte: Sparte,
+    var sparteE: SparteE,
     var klasse: String?,                    // z.B. "L", "115cm", "Reiterpass"
     var kategorieOetoDesBewerbs: String?, // ÖTO Kategorie, z.B. "CDN-C Neu". Kann vom Turnier abweichen/spezifischer sein.
     // Wird für die Gültigkeit von Regeln/Lizenzen herangezogen.

shared/src/commonMain/kotlin/at/mocode/shared/model/Pruefungsaufgabe.kt

@@ -1,6 +1,6 @@
 package at.mocode.shared.model
 
-import at.mocode.shared.enums.Sparte
+import at.mocode.shared.enums.SparteE
 import at.mocode.shared.serializers.KotlinInstantSerializer
 import at.mocode.shared.serializers.UuidSerializer
 import com.benasher44.uuid.Uuid
@@ -16,7 +16,7 @@ data class Pruefungsaufgabe(
     var kuerzel: String, // Eindeutiges Kürzel, z.B. "A1", "LF3", "FEI GP PSG"
     var nameLang: String, // Vollständiger Name, z.B. "Dressuraufgabe A1 (GM, 20x40m)"
     var kategorieText: String?, // Übergeordnete Kategorie, z.B. "Dressuraufgaben Klasse A", "FEI Grand Prix Serie"
-    var sparte: Sparte, // Primär DRESSUR, aber auch für Vielseitigkeit etc.
+    var sparteE: SparteE, // Primär DRESSUR, aber auch für Vielseitigkeit etc.
     var nation: PruefungsaufgabeNationEnum = PruefungsaufgabeNationEnum.NATIONAL,
     var richtverfahrenModusDefault: PruefungsaufgabeRichtverfahrenModusEnum?, // GM, GT - als Default für diese Aufgabe
     var viereckGroesseDefault: PruefungsaufgabeViereckEnum?, // VIERECK_20x40, VIERECK_20x60 - als Default

shared/src/commonMain/kotlin/at/mocode/shared/model/Richtverfahren.kt

@@ -1,6 +1,6 @@
 package at.mocode.shared.model
 
-import at.mocode.shared.enums.Sparte
+import at.mocode.shared.enums.SparteE
 import at.mocode.shared.serializers.KotlinInstantSerializer
 import at.mocode.shared.serializers.UuidSerializer
 import com.benasher44.uuid.Uuid
@@ -15,7 +15,7 @@ data class Richtverfahren(
     val id: Uuid = uuid4(),
     var code: String, // Eindeutiger Code, z.B. "A", "A2_OETO204", "C_ZEIT", "STIL_A_IDEALZEIT"
     var bezeichnung: String, // z.B. "Standardspringprüfung nach Fehlern und Zeit (§204 A2)", "Stilspringprüfung Kl. A mit Idealzeit"
-    var sparte: Sparte,
+    var sparteE: SparteE,
     var basisRegelnBeschreibungKurz: String?, // Kurze Beschreibung oder Hauptmerkmal
     var oetoParagraphVerweis: String?, // z.B. "ÖTO §204 A2", "ÖTO §104"
     var hatStechen: Boolean = false,

shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/verein/DomPerson.kt

@@ -0,0 +1,98 @@
+import at.mocode.shared.enums.DatenQuelleE
+import at.mocode.shared.enums.GeschlechtE
+import at.mocode.shared.serializers.KotlinInstantSerializer
+import at.mocode.shared.serializers.KotlinLocalDateSerializer
+import at.mocode.shared.serializers.UuidSerializer
+import com.benasher44.uuid.Uuid
+import com.benasher44.uuid.uuid4
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.datetime.LocalDate
+import kotlinx.serialization.Serializable
+
+/**
+ * Repräsentiert eine Person (Reiter, Funktionär, Kontaktperson etc.)
+ * im Domänenmodell der Anwendung.
+ *
+ * Die Daten können aus dem OEPS ZNS-Import (`Person_ZNS_Staging`) stammen
+ * oder manuell im System angelegt werden.
+ *
+ * @property personId Eindeutiger interner Identifikator für diese Person (UUID).
+ * @property oepsSatzNr Die offizielle 6-stellige OEPS-Satznummer der Person, falls vorhanden. Eindeutig.
+ * @property nachname Familienname der Person.
+ * @property vorname Vorname der Person.
+ * @property titel Akademischer Titel oder Anrede (z.B. Dr., Ing.).
+ * @property geburtsdatum Geburtsdatum der Person.
+ * @property geschlecht Geschlecht der Person.
+ * @property nationalitaetLandId Fremdschlüssel zur `LandDefinition` für die Nationalität.
+ * @property feiId Optionale FEI-Identifikationsnummer der Person.
+ * @property telefon Private oder geschäftliche Telefonnummer.
+ * @property email Private oder geschäftliche E-Mail-Adresse.
+ * @property strasse Straße und Hausnummer der Hauptadresse.
+ * @property plz Postleitzahl der Hauptadresse.
+ * @property ort Ortschaft der Hauptadresse.
+ * @property adresszusatzZusatzinfo Weitere Adressinformationen.
+ * @property stammVereinId Optionale Verknüpfung zum `DomVerein` (Stammverein der Person).
+ * @property mitgliedsNummerBeiStammVerein Mitgliedsnummer der Person beim Stammverein.
+ * @property istGesperrt Gibt an, ob die Person laut OEPS oder intern gesperrt ist.
+ * @property sperrGrund Begründung für eine eventuelle Sperre.
+ * @property altersklasseOepsCodeRaw Der Roh-Code für die Altersklasse aus dem ZNS-Import (z.B. "JG", "JR", "25").
+ * Dient zur Ableitung oder als Information.
+ * @property istJungerReiterOepsFlag Ob die Person im ZNS als "Junger Reiter" ("Y") gekennzeichnet ist.
+ * @property kaderStatusOepsRaw Kaderkennzeichen aus dem ZNS-Import.
+ * @property datenQuelle Gibt die Herkunft dieses Datensatzes an (z.B. OEPS_ZNS, MANUELL).
+ * @property istAktiv Gibt an, ob dieser Personendatensatz aktuell aktiv ist.
+ * @property notizenIntern Interne Anmerkungen oder Notizen zu dieser Person.
+ * @property createdAt Zeitstempel der Erstellung dieses Datensatzes.
+ * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes.
+ */
+@Serializable
+data class DomPerson(
+    @Serializable(with = UuidSerializer::class)
+    val personId: Uuid = uuid4(),
+
+    var oepsSatzNr: String?, // Wird aus Person_ZNS_Staging.oepsSatzNrPerson befüllt, UNIQUE
+    var nachname: String,    // Wird aus Person_ZNS_Staging.familiennameRoh befüllt
+    var vorname: String,     // Wird aus Person_ZNS_Staging.vornameRoh befüllt
+    var titel: String? = null, // Manuelle Eingabe oder ggf. später aus ZNS falls vorhanden
+
+    @Serializable(with = KotlinLocalDateSerializer::class)
+    var geburtsdatum: LocalDate? = null, // Konvertiert aus Person_ZNS_Staging.geburtsdatumTextRoh
+
+    var geschlecht: GeschlechtE? = null,   // Konvertiert aus Person_ZNS_Staging.geschlechtCodeRoh
+
+    @Serializable(with = UuidSerializer::class)
+    var nationalitaetLandId: Uuid? = null, // Aufgelöst aus Person_ZNS_Staging.nationalitaetCodeRoh via LandDefinition
+
+    var feiId: String? = null,           // Wird aus Person_ZNS_Staging.feiIdPersonRoh befüllt
+
+    var telefon: String? = null,         // Wird aus Person_ZNS_Staging.telefonRoh befüllt
+    var email: String? = null,           // Manuelle Eingabe, nicht in LIZENZ01.dat
+
+    // Adresse (manuelle Eingabe, nicht primär in LIZENZ01.dat für Person direkt)
+    var strasse: String? = null,
+    var plz: String? = null,
+    var ort: String? = null,
+    var adresszusatzZusatzinfo: String? = null,
+
+    @Serializable(with = UuidSerializer::class)
+    var stammVereinId: Uuid? = null,     // Aufgelöst aus Person_ZNS_Staging.vereinsnameOepsRoh & bundeslandCodeOepsRoh via DomVerein
+    var mitgliedsNummerBeiStammVerein: String? = null, // Wird aus Person_ZNS_Staging.mitgliedNrVereinRoh befüllt
+
+    var istGesperrt: Boolean = false,   // Konvertiert aus Person_ZNS_Staging.sperrlisteFlagOepsRoh ("S" -> true)
+    var sperrGrund: String? = null,     // Manuelle Eingabe
+
+    var altersklasseOepsCodeRaw: String? = null, // Speichert Roh-Code "JG", "JR", "25"
+    var istJungerReiterOepsFlag: Boolean = false, // true wenn Roh-Code "Y"
+
+    var kaderStatusOepsRaw: String? = null, // Speichert Roh-Code (aktuell meist BLANK)
+
+    var datenQuelle: DatenQuelleE = DatenQuelleE.MANUELL,
+    var istAktiv: Boolean = true,
+    var notizenIntern: String? = null,
+
+    @Serializable(with = KotlinInstantSerializer::class)
+    val createdAt: Instant = Clock.System.now(),
+    @Serializable(with = KotlinInstantSerializer::class)
+    var updatedAt: Instant = Clock.System.now()
+)

shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/verein/DomPferd.kt

@@ -0,0 +1,84 @@
+import at.mocode.shared.enums.DatenQuelleE
+import at.mocode.shared.enums.PferdeGeschlechtE // NEUES ENUM
+import at.mocode.shared.serializers.KotlinInstantSerializer
+import at.mocode.shared.serializers.UuidSerializer
+import com.benasher44.uuid.Uuid
+import com.benasher44.uuid.uuid4
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.serialization.Serializable
+
+/**
+ * Repräsentiert ein Pferd im Domänenmodell der Anwendung.
+ *
+ * Die Daten für ein Pferd können aus dem OEPS ZNS-Import (`Pferd_ZNS_Staging`)
+ * stammen oder manuell im System angelegt werden (z.B. für ausländische Pferde oder
+ * Pferde ohne OEPS-Registrierung, die z.B. in lizenzfreien Bewerben starten).
+ *
+ * @property pferdId Eindeutiger interner Identifikator für dieses Pferd (UUID).
+ * @property oepsSatzNrPferd Die offizielle 10-stellige OEPS-Satznummer des Pferdes, falls vorhanden. Eindeutig.
+ * @property oepsKopfNr Die offizielle 4-stellige OEPS-Kopfnummer des Pferdes, falls vorhanden.
+ * @property name Der Name des Pferdes.
+ * @property lebensnummer Die Lebensnummer des Pferdes (UELN), falls bekannt.
+ * @property feiPassNr Die FEI-Passnummer des Pferdes, falls vorhanden.
+ * @property geburtsjahr Geburtsjahr des Pferdes.
+ * @property geschlecht Geschlecht des Pferdes.
+ * @property farbe Farbe des Pferdes.
+ * @property rasse Rasse des Pferdes.
+ * @property abstammungVaterName Name des Vaters.
+ * @property abstammungMutterName Name der Mutter.
+ * @property abstammungMutterVaterName Name des Muttervaters.
+ * @property abstammungZusatzInfo Allgemeine Abstammungsinformationen aus dem ZNS (Feld "ABSTAMMUNG").
+ * @property besitzerPersonId Optionale Verknüpfung zur `DomPerson` (Besitzer).
+ * @property verantwortlichePersonId Optionale Verknüpfung zur `DomPerson` (Verantwortliche Person lt. ZNS).
+ * @property heimatVereinId Optionale Verknüpfung zum `DomVerein` (Heimatverein des Pferdes lt. ZNS).
+ * @property letzteZahlungPferdegebuehrJahrOeps Jahr der letzten Zahlung der OEPS-Pferdegebühr.
+ * @property stockmassCm Stockmaß des Pferdes in cm.
+ * @property datenQuelle Gibt die Herkunft dieses Datensatzes an.
+ * @property istAktiv Gibt an, ob dieser Pferdedatensatz aktuell aktiv ist.
+ * @property notizenIntern Interne Anmerkungen oder Notizen zu diesem Pferd.
+ * @property createdAt Zeitstempel der Erstellung dieses Datensatzes.
+ * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes.
+ */
+@Serializable
+data class DomPferd(
+    @Serializable(with = UuidSerializer::class)
+    val pferdId: Uuid = uuid4(),
+
+    var oepsSatzNrPferd: String?, // Aus Pferd_ZNS_Staging.oepsSatzNrPferd, UNIQUE
+    var oepsKopfNr: String?,      // Aus Pferd_ZNS_Staging.oepsKopfNrRoh
+    var name: String,             // Aus Pferd_ZNS_Staging.nameRoh
+
+    var lebensnummer: String? = null,   // Aus Pferd_ZNS_Staging.lebensnummerRoh
+    var feiPassNr: String? = null,      // Aus Pferd_ZNS_Staging.feiPassNrRoh
+
+    var geburtsjahr: Int? = null,       // Konvertiert aus Pferd_ZNS_Staging.geburtsjahrRoh
+    var geschlecht: PferdeGeschlechtE? = null, // Konvertiert aus Pferd_ZNS_Staging.geschlechtCodeRoh
+    var farbe: String? = null,          // Aus Pferd_ZNS_Staging.farbeRoh
+    var rasse: String? = null,          // Nicht direkt in PFERDE01.dat, aber oft bekannt/wichtig
+
+    var abstammungVaterName: String? = null, // Aus Pferd_ZNS_Staging.abstammungVaterNameRoh
+    var abstammungMutterName: String? = null, // Manuell oder andere Quelle
+    var abstammungMutterVaterName: String? = null, // Manuell oder andere Quelle
+    var abstammungZusatzInfo: String? = null, // Aus Pferd_ZNS_Staging.abstammungInfoRoh
+
+    @Serializable(with = UuidSerializer::class)
+    var besitzerPersonId: Uuid? = null, // Muss aufgelöst werden (Name in Pferd_ZNS_Staging.verantwortlichePersonNameRoh, oder separate Besitzerinfo?)
+    @Serializable(with = UuidSerializer::class)
+    var verantwortlichePersonId: Uuid? = null, // Muss aufgelöst werden aus Pferd_ZNS_Staging.verantwortlichePersonNameRoh
+
+    @Serializable(with = UuidSerializer::class)
+    var heimatVereinId: Uuid? = null,    // Muss aufgelöst werden aus Pferd_ZNS_Staging.oepsVereinNrPferdRoh via DomVerein
+
+    var letzteZahlungPferdegebuehrJahrOeps: Int? = null, // Konvertiert aus Pferd_ZNS_Staging.letzteZahlungPferdegebuehrJahrRoh
+    var stockmassCm: Int? = null,       // Nicht in PFERDE01.dat
+
+    var datenQuelle: DatenQuelleE = DatenQuelleE.MANUELL,
+    var istAktiv: Boolean = true,
+    var notizenIntern: String? = null,
+
+    @Serializable(with = KotlinInstantSerializer::class)
+    val createdAt: Instant = Clock.System.now(),
+    @Serializable(with = KotlinInstantSerializer::class)
+    var updatedAt: Instant = Clock.System.now()
+)

shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/verein/DomVerein.kt

@@ -0,0 +1,70 @@
+package at.mocode.shared.model.domaene.verein
+
+import at.mocode.shared.enums.DatenQuelleE
+import at.mocode.shared.serializers.KotlinInstantSerializer
+import at.mocode.shared.serializers.UuidSerializer
+import com.benasher44.uuid.Uuid
+import com.benasher44.uuid.uuid4
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.serialization.Serializable
+
+/**
+ * Repräsentiert einen Reitverein im Domänenmodell der Anwendung.
+ *
+ * Die Daten für einen Verein können aus dem OEPS ZNS-Import (`Verein_ZNS_Staging`)
+ * stammen oder manuell im System angelegt werden (z.B. für ausländische Vereine).
+ * Jeder Verein wird durch eine systeminterne UUID und die offizielle OEPS-Vereinsnummer
+ * (falls vorhanden) eindeutig identifiziert.
+ *
+ * @property vereinId Eindeutiger interner Identifikator für diesen Verein (UUID).
+ * @property oepsVereinsNr Die offizielle 4-stellige OEPS-Vereinsnummer. Sollte eindeutig sein, falls vorhanden.
+ * @property name Der offizielle Name des Vereins.
+ * @property kuerzel Ein optionales Kürzel oder eine Kurzbezeichnung für den Verein.
+ * @property adresseStrasse Straße und Hausnummer des Vereinssitzes.
+ * @property plz Postleitzahl des Vereinssitzes.
+ * @property ort Ortschaft des Vereinssitzes.
+ * @property bundeslandId Optionale Verknüpfung zur `BundeslandDefinition`. Für OEPS-Vereine
+ * wird versucht, dies aus der ersten Ziffer der `oepsVereinsNr` abzuleiten.
+ * @property landId Verknüpfung zur `LandDefinition`. Für OEPS-Vereine ist dies "Österreich".
+ * @property emailAllgemein Allgemeine E-Mail-Adresse des Vereins.
+ * @property telefonAllgemein Allgemeine Telefonnummer des Vereins.
+ * @property webseiteUrl URL zur Webseite des Vereins.
+ * @property datenQuelle Gibt die Herkunft dieses Datensatzes an (z.B. OEPS_ZNS, MANUELL).
+ * @property istAktiv Gibt an, ob dieser Verein aktuell aktiv ist und im System verwendet werden kann.
+ * @property notizenIntern Interne Anmerkungen oder Notizen zu diesem Verein.
+ * @property createdAt Zeitstempel der Erstellung dieses Datensatzes.
+ * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes.
+ */
+@Serializable
+data class DomVerein(
+    @Serializable(with = UuidSerializer::class)
+    val vereinId: Uuid = uuid4(),
+
+    var oepsVereinsNr: String?, // Kann null sein für nicht-OEPS Vereine. Wenn gesetzt, erste Ziffer = Bundesland-Code.
+    var name: String,
+    var kuerzel: String? = null,
+
+    var adresseStrasse: String? = null,
+    var plz: String? = null,
+    var ort: String? = null,
+
+    @Serializable(with = UuidSerializer::class)
+    var bundeslandId: Uuid? = null, // FK zu BundeslandDefinition.bundeslandId
+
+    @Serializable(with = UuidSerializer::class)
+    var landId: Uuid,          // FK zu LandDefinition.landId (jeder Verein ist in einem Land)
+
+    var emailAllgemein: String? = null,
+    var telefonAllgemein: String? = null,
+    var webseiteUrl: String? = null,
+
+    var datenQuelle: DatenQuelleE = DatenQuelleE.OEPS_ZNS, // default OEPS_ZNS
+    var istAktiv: Boolean = true,
+    var notizenIntern: String? = null,
+
+    @Serializable(with = KotlinInstantSerializer::class)
+    val createdAt: Instant = Clock.System.now(),
+    @Serializable(with = KotlinInstantSerializer::class)
+    var updatedAt: Instant = Clock.System.now()
+)

shared/src/commonMain/kotlin/at/mocode/shared/model/oeto_verwaltung/AltersklasseDefinition.kt

@@ -0,0 +1,59 @@
+package at.mocode.shared.model.oeto_verwaltung
+
+import at.mocode.shared.enums.SparteE // Optional, falls Altersklassen stark spartenspezifisch sind
+import at.mocode.shared.serializers.KotlinInstantSerializer
+import at.mocode.shared.serializers.UuidSerializer
+import com.benasher44.uuid.Uuid
+import com.benasher44.uuid.uuid4
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.serialization.Serializable
+
+/**
+ * Definiert eine spezifische Altersklasse für Teilnehmer (Reiter, Fahrer, Voltigierer)
+ * oder ggf. auch für Pferde, basierend auf den Vorgaben der ÖTO oder anderer Regelwerke.
+ *
+ * Beispiele: "Jugend U16", "Junioren U18", "Junge Reiter U21", "Allgemeine Klasse",
+ * "Pony Jugend U14", "Senioren Ü40".
+ * Diese Definitionen dienen zur Überprüfung von Teilnahmeberechtigungen in Bewerben und Abteilungen.
+ *
+ * @property altersklasseId Eindeutiger interner Identifikator für diese Altersklassendefinition (UUID).
+ * @property altersklasseCode Ein eindeutiges Kürzel oder Code für die Altersklasse
+ * (z.B. "JGD_U16", "JUN_U18", "YR_U21", "AK", "PONY_U14"). Dient als fachlicher Schlüssel.
+ * @property bezeichnung Die offizielle oder allgemein verständliche Bezeichnung der Altersklasse.
+ * @property minAlter Das Mindestalter (Jahre, inklusive) für diese Altersklasse. `null`, wenn es keine Untergrenze gibt.
+ * @property maxAlter Das Höchstalter (Jahre, inklusive) für diese Altersklasse. `null`, wenn es keine Obergrenze gibt.
+ * @property stichtagRegelText Eine Beschreibung der Regel für den Stichtag zur Altersberechnung
+ * (z.B. "31.12. des laufenden Kalenderjahres", "Geburtstag im laufenden Jahr").
+ * @property sparteFilter Optionale Angabe, ob diese Altersklassendefinition nur für eine spezifische Sparte gilt.
+ * @property geschlechtFilter Optionaler Filter für das Geschlecht ('M', 'W'), falls die Altersklasse geschlechtsspezifisch ist.
+ * `null` bedeutet für alle Geschlechter gültig.
+ * @property oetoRegelReferenzId Optionale Verknüpfung zu einer spezifischen Regel in der `OETORegelReferenz`-Tabelle,
+ * die diese Altersklasse definiert.
+ * @property istAktiv Gibt an, ob diese Altersklassendefinition aktuell im System verwendet werden kann.
+ * @property createdAt Zeitstempel der Erstellung dieses Datensatzes.
+ * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes.
+ */
+@Serializable
+data class AltersklasseDefinition(
+    @Serializable(with = UuidSerializer::class)
+    val altersklasseId: Uuid = uuid4(), // Interner Primärschlüssel
+
+    var altersklasseCode: String,       // Fachlicher PK, z.B. "JGD_U16"
+    var bezeichnung: String,
+    var minAlter: Int? = null,
+    var maxAlter: Int? = null,
+    var stichtagRegelText: String? = "31.12. des laufenden Kalenderjahres", // Typischer Default
+    var sparteFilter: SparteE? = null, // Ist diese Definition spartenspezifisch?
+    var geschlechtFilter: Char? = null, // 'M', 'W', oder null für beide
+
+    @Serializable(with = UuidSerializer::class)
+    var oetoRegelReferenzId: Uuid? = null, // FK zu OETORegelReferenz.oetoRegelReferenzId
+
+    var istAktiv: Boolean = true,
+
+    @Serializable(with = KotlinInstantSerializer::class)
+    val createdAt: Instant = Clock.System.now(),
+    @Serializable(with = KotlinInstantSerializer::class)
+    var updatedAt: Instant = Clock.System.now()
+)

shared/src/commonMain/kotlin/at/mocode/shared/model/oeto_verwaltung/LizenzTypGlobal.kt

@@ -0,0 +1,70 @@
+package at.mocode.shared.model.oeto_verwaltung
+
+import at.mocode.shared.enums.LizenzKategorieE
+import at.mocode.shared.enums.SparteE
+import at.mocode.shared.enums.VerbandE // Wiederverwendung von VerbandE
+import at.mocode.shared.serializers.KotlinInstantSerializer
+import at.mocode.shared.serializers.UuidSerializer
+import com.benasher44.uuid.Uuid
+import com.benasher44.uuid.uuid4
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.serialization.Serializable
+
+/**
+ * Definiert einen globalen Typ einer Lizenz oder Startkarte gemäß der Systematik
+ * des OEPS oder anderer relevanter Verbände (z.B. FEI).
+ *
+ * Diese Entität dient als zentrale Referenz für alle im System bekannten Lizenzarten,
+ * ihre grundlegenden Eigenschaften und wie sie ggf. aus kombinierten Kürzeln
+ * aufgeschlüsselt werden.
+ *
+ * @property lizenzTypGlobalId Eindeutiger interner Identifikator für diesen globalen Lizenztyp (UUID).
+ * @property lizenzTypGlobalCode Das offizielle und eindeutige Kürzel des Lizenztyps
+ * (z.B. "R1", "RD2", "S" für Startkarte allgemein, "F1", "R1S2" für eine Kombi-Lizenz).
+ * Dient als fachlicher Primärschlüssel. Die Länge sollte auch längere Kombi-Kürzel erlauben.
+ * @property bezeichnung Die offizielle oder allgemein verständliche Bezeichnung des Lizenztyps
+ * (z.B. "Reiterlizenz R1", "Reiterlizenz Dressur D2", "Startkarte Allgemein", "Fahrerlizenz F1").
+ * @property spartePrimaer Die primäre Pferdesportsparte, für die dieser Lizenztyp hauptsächlich relevant ist.
+ * Kann `null` sein, wenn spartenübergreifend oder nicht eindeutig zuzuordnen (z.B. bei manchen Startkarten).
+ * @property kategorieLizenzText Eine übergeordnete Kategorie zur Gruppierung von Lizenzen
+ * (z.B. "Reiterlizenz", "Fahrerlizenz", "Startkarte", "Sonderlizenz").
+ * @property stufe Die Stufe oder das Level der Lizenz, falls anwendbar (z.B. "1", "2", "S", "M", "GP").
+ * @property beschreibungBerechtigung Eine kurze Beschreibung der Berechtigungen oder des Geltungsbereichs
+ * dieser Lizenz (z.B. "Startberechtigung Dressur & Springen Klasse A", "Nationale Turniere").
+ * @property aufschluesselungKombilizenzCodes Eine optionale Liste von Basis-`lizenzTypGlobalCode`s,
+ * falls dieser Lizenztyp eine Kombination darstellt (z.B. für "R1S2" könnte hier ["R1", "RS2"] stehen,
+ * wobei "R1" und "RS2" dann eigene `LizenzTypGlobal`-Einträge wären). Dies hilft bei der
+ * detaillierten Berechtigungsprüfung.
+ * @property zustaendigerVerband Der Verband, der diesen Lizenztyp primär definiert oder ausstellt.
+ * @property oetoRegelReferenzId Optionale Verknüpfung zu einer spezifischen Regel in der `OETORegelReferenz`-Tabelle,
+ * die diesen Lizenztyp definiert.
+ * @property istAktiv Gibt an, ob dieser Lizenztyp aktuell im System verwendet und bei der Nennung
+ * oder Funktionärszuordnung ausgewählt werden kann.
+ * @property createdAt Zeitstempel der Erstellung dieses Datensatzes.
+ * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes.
+ */
+@Serializable
+data class LizenzTypGlobal(
+    @Serializable(with = UuidSerializer::class)
+    val lizenzTypGlobalId: Uuid = uuid4(), // Interner Primärschlüssel
+
+    var lizenzTypGlobalCode: String, // Fachlicher PK, z.B. "R1", "RD2", "R1S2"
+    var bezeichnung: String,
+    var spartePrimaer: SparteE? = null,
+    var kategorieLizenzText: LizenzKategorieE, // z.B. "Reiterlizenz", "Startkarte"
+    var stufe: String? = null,
+    var beschreibungBerechtigung: String? = null,
+    var aufschluesselungKombilizenzCodes: List<String>? = null, // Liste von lizenzTypGlobalCode(s)
+    var zustaendigerVerband: VerbandE = VerbandE.OEPS,
+
+    @Serializable(with = UuidSerializer::class)
+    var oetoRegelReferenzId: Uuid? = null, // FK zu OETORegelReferenz.oetoRegelReferenzId
+
+    var istAktiv: Boolean = true,
+
+    @Serializable(with = KotlinInstantSerializer::class)
+    val createdAt: Instant = Clock.System.now(),
+    @Serializable(with = KotlinInstantSerializer::class)
+    var updatedAt: Instant = Clock.System.now()
+)

shared/src/commonMain/kotlin/at/mocode/shared/model/oeto_verwaltung/OETORegelReferenz.kt

@@ -0,0 +1,60 @@
+package at.mocode.shared.model.oeto_verwaltung
+
+import at.mocode.shared.enums.RegelwerkTypE
+import at.mocode.shared.serializers.KotlinInstantSerializer
+import at.mocode.shared.serializers.KotlinLocalDateSerializer
+import at.mocode.shared.serializers.UuidSerializer
+import com.benasher44.uuid.Uuid
+import com.benasher44.uuid.uuid4
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.datetime.LocalDate
+import kotlinx.serialization.Serializable
+
+/**
+ * Repräsentiert einen spezifischen Verweis auf eine Regel, einen Paragrafen oder einen
+ * Abschnitt innerhalb eines offiziellen Regelwerks, primär der österreichischen Turnierordnung (ÖTO)
+ * oder des FEI-Reglements.
+ *
+ * Diese Entität dient dazu, Datenmodellentscheidungen, spezifische Anforderungen in Bewerben
+ * oder Lizenzbedingungen nachvollziehbar mit der jeweiligen offiziellen Regelgrundlage
+ * zu verknüpfen. Sie ermöglicht eine zentrale Verwaltung und Referenzierung von
+ * Regelwerksbestandteilen.
+ *
+ * @property oetoRegelReferenzId Eindeutiger Identifikator für diesen Regelverweis (UUID).
+ * @property paragraphNummer Die genaue Bezeichnung des Paragrafen, Artikels oder Abschnitts
+ * (z.B. "§15", "§104 Abs. 2 Z1", "FEI Art. 240").
+ * @property kapitelTitel Optionaler Titel des Kapitels oder übergeordneten Abschnitts,
+ * in dem sich die Regel befindet (z.B. "Reiterlizenzen", "Richtverfahren A").
+ * @property kurzbeschreibungRegel Optionale kurze Zusammenfassung oder Beschreibung des Inhalts der Regel.
+ * @property regelwerkTyp Gibt an, auf welches Regelwerk sich dieser Verweis bezieht (z.B. ÖTO, FEI).
+ * @property versionDatum Das Datum der Version des Regelwerks, auf das sich dieser Verweis bezieht,
+ * um die Gültigkeit im Kontext der jeweiligen Regelwerksausgabe sicherzustellen.
+ * @property urlDetail Optionaler URL-Link zur Online-Quelle der spezifischen Regel oder des Dokuments.
+ * @property istAktiv Gibt an, ob dieser Regelverweis aktuell gültig und in Verwendung ist.
+ * Veraltete Verweise können so markiert werden, ohne sie physisch zu löschen.
+ * @property createdAt Zeitstempel der Erstellung dieses Datensatzes in der lokalen Datenbank.
+ * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes in der lokalen Datenbank.
+ */
+@Serializable
+data class OETORegelReferenz(
+
+    @Serializable(with = UuidSerializer::class)
+    val oetoRegelReferenzId: Uuid = uuid4(),
+
+    var paragraphNummer: String,
+    var kapitelTitel: String? = null,
+    var kurzbeschreibungRegel: String? = null,
+    var regelwerkTyp: RegelwerkTypE,     // OETO, FEI, SONSTIGE
+
+    @Serializable(with = KotlinLocalDateSerializer::class)
+    var versionDatum: LocalDate,
+
+    var urlDetail: String? = null,
+    var istAktiv: Boolean = true,
+
+    @Serializable(with = KotlinInstantSerializer::class)
+    val createdAt: Instant = Clock.System.now(),
+    @Serializable(with = KotlinInstantSerializer::class)
+    var updatedAt: Instant = Clock.System.now()
+)

shared/src/commonMain/kotlin/at/mocode/shared/model/oeto_verwaltung/QualifikationsTyp.kt

@@ -0,0 +1,58 @@
+package at.mocode.shared.model.oeto_verwaltung
+
+import at.mocode.shared.enums.SparteE
+import at.mocode.shared.enums.VerbandE
+import at.mocode.shared.serializers.KotlinInstantSerializer
+import at.mocode.shared.serializers.UuidSerializer
+import com.benasher44.uuid.Uuid
+import com.benasher44.uuid.uuid4
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.serialization.Serializable
+
+/**
+ * Definiert einen spezifischen Typ einer Funktionärsqualifikation gemäß den
+ * Richtlinien der ÖTO oder anderer relevanter Verbände.
+ *
+ * Beispiele für Qualifikationstypen sind "Richter Dressur bis Grand Prix" (R-DGP),
+ * "Parcoursbauer Springen bis Klasse S*" (PB-S*), "Technischer delegierter National" (TD-NAT),
+ * oder auch spezifische Ausbilder-Qualifikationen.
+ * Diese Entität dient als zentrale Referenz für die im System bekannten und
+ * verwaltbaren Funktionärsqualifikationen.
+ *
+ * @property qualTypId Eindeutiger interner Identifikator für diesen Qualifikationstyp (UUID).
+ * @property qualTypCode Eindeutiger Code oder Kürzel für den Qualifikationstyp,
+ * wie er vom OEPS oder anderen Verbänden verwendet wird (z.B. "R-DPF-S", "PB-S*", "STEWARD-FEI-L2").
+ * Dieser Code dient als Primärschlüssel für die fachliche Identifikation.
+ * @property bezeichnung Die offizielle oder allgemein verständliche Bezeichnung des Qualifikationstyps
+ * (z.B. "Richter Dressurpferdeprüfung bis Klasse S", "Parcoursbauer Springen Kategorie S*", "FEI Steward Level 2").
+ * @property sparte Die primäre Pferdesportsparte, für die diese Qualifikation relevant ist.
+ * Kann auch spartenübergreifend sein (z.B. für Stewards).
+ * @property zustaendigerVerband Optional der Verband, der diese Qualifikation ausstellt oder definiert (z.B. "OEPS", "FEI").
+ * @property oetoRegelReferenzId Optionale Verknüpfung zu einer spezifischen Regel in der `OETORegelReferenz`-Tabelle,
+ * die diese Qualifikation definiert oder beschreibt.
+ * @property istAktiv Gibt an, ob dieser Qualifikationstyp aktuell im System verwendet werden kann.
+ * @property createdAt Zeitstempel der Erstellung dieses Datensatzes.
+ * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes.
+ */
+@Serializable
+data class QualifikationsTyp(
+    @Serializable(with = UuidSerializer::class)
+    val qualTypId: Uuid = uuid4(),
+
+    var qualTypCode: String,
+    var bezeichnung: String,
+    var sparte: SparteE,
+    var zustaendigerVerband: VerbandE = VerbandE.OEPS, // Default OEPS
+    var beschreibungDetails: String? = null,
+
+    @Serializable(with = UuidSerializer::class)
+    var oetoRegelReferenzId: Uuid? = null, // FK zu OETORegelReferenz.oetoRegelReferenzId
+
+    var istAktiv: Boolean = true,
+
+    @Serializable(with = KotlinInstantSerializer::class)
+    val createdAt: Instant = Clock.System.now(),
+    @Serializable(with = KotlinInstantSerializer::class)
+    var updatedAt: Instant = Clock.System.now()
+)

shared/src/commonMain/kotlin/at/mocode/shared/model/oeto_verwaltung/Sportfachliche_Stammdaten.kt

@@ -0,0 +1,73 @@
+package at.mocode.shared.model.oeto_verwaltung
+
+import at.mocode.shared.enums.*
+import at.mocode.shared.serializers.KotlinInstantSerializer
+import at.mocode.shared.serializers.UuidSerializer
+import com.benasher44.uuid.Uuid
+import com.benasher44.uuid.uuid4
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.serialization.Serializable
+
+/**
+ * Zentrale Entität zur Speicherung verschiedener, wiederverwendbarer sportfachlicher Definitionen
+ * und Stammdaten, die nicht in spezifischere Entitäten wie `LizenzTypGlobal` oder
+ * `QualifikationsTyp` passen. Die Art des Stammdatums wird durch das Feld `typ` definiert.
+ *
+ * Beispiele für Typen:
+ * - DRESSURAUFGABE: Definition einer spezifischen Dressuraufgabe (z.B. "A1", "LF3").
+ * - WERTUNGSVERFAHREN_SPRINGEN: Definition eines Richtverfahrens im Springen (z.B. "A2 nach ÖTO §204").
+ * - WERTUNGSVERFAHREN_DRESSUR: Definition eines Richtverfahrens in der Dressur (z.B. "GM", "GT").
+ * - BEWERBSKLASSE: Definition einer Leistungsklasse (z.B. "Klasse A", "115cm Höhe").
+ * - BEWERBSKATEGORIE_OETO: Definition einer offiziellen ÖTO-Turnier-/Bewerbskategorie (z.B. "CDN-C Neu").
+ * - HINDERNISTYP: Definition von Standard-Hindernistypen im Springen.
+ * - RVK_PUNKTETABELLE: Punktetabellen für den Reitervierkampf.
+ * - OETO_REGEL_TEXT: Freitextauszüge oder Erläuterungen zu spezifischen ÖTO-Regeln.
+ *
+ * @property stammdatumId Eindeutiger interner Identifikator für diesen Stammdatensatz (UUID).
+ * @property typ Der Typ des sportfachlichen Stammdatums (siehe `SportfachStammdatenTypE`).
+ * Bestimmt, wie die anderen Felder, insbesondere `detailsJson`, zu interpretieren sind.
+ * @property code Ein eindeutiger Code oder Kürzel für diesen Stammdatensatz,
+ * typischerweise eindeutig innerhalb des jeweiligen `typs` (z.B. "A1" für Typ DRESSURAUFGABE,
+ * "CDN-CNEU" für Typ BEWERBSKATEGORIE_OETO).
+ * @property bezeichnung Die offizielle oder allgemein verständliche Bezeichnung dieses Stammdatums.
+ * @property detailsJson Optionale, strukturierte Zusatzinformationen im JSON-Format,
+ * deren Inhalt vom `typ` abhängt.
+ * Beispiele:
+ * - Für DRESSURAUFGABE: Lektionen, Dauer, Max-Punkte.
+ * - Für WERTUNGSVERFAHREN: Spezifische Fehlerwerte, Zeitregeln.
+ * - Für BEWERBSKLASSE: Höhenangaben im Springen, Anforderungen in Dressur.
+ * @property sparteZugehoerigkeit Optionale primäre Pferdesportsparte, für die dieser Stammdatensatz relevant ist.
+ * Kann `null` sein, wenn spartenübergreifend oder nicht direkt zuzuordnen.
+ * @property verbandGueltigkeit Für Aufgaben oder Regelwerke relevant, ob sie national (OEPS), FEI oder von anderer Nation sind.
+ * @property viereckGroesse Standard-Viereckgröße, relevant für Typ DRESSURAUFGABE.
+ * @property richtverfahrenModus Standard-Richtverfahrensmodus (GM/GT), relevant für Typ DRESSURAUFGABE.
+ * @property oetoRegelReferenzId Optionale Verknüpfung zu einer spezifischen Regel in der `OETORegelReferenz`-Tabelle.
+ * @property istAktiv Gibt an, ob dieser Stammdatensatz aktuell im System verwendet werden kann.
+ * @property createdAt Zeitstempel der Erstellung dieses Datensatzes.
+ * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes.
+ */
+@Serializable
+data class Sportfachliche_Stammdaten(
+    @Serializable(with = UuidSerializer::class)
+    val stammdatumId: Uuid = uuid4(),
+
+    var typ: SportfachStammdatenTypE,
+    var code: String, // Eindeutig pro Typ, z.B. "A1", "CDN-CNEU", "115CM"
+    var bezeichnung: String,
+    var detailsJson: String? = null, // Strukturierte Details als JSON-String
+    var sparteZugehoerigkeit: SparteE? = null,
+    var verbandGueltigkeit: VerbandE? = null, // für Aufgaben/Regeln
+    var viereckGroesse: PruefungsViereckE? = null, // für Dressuraufgaben
+    var richtverfahrenModus: RichtverfahrenModusE? = null, // für Dressuraufgaben
+
+    @Serializable(with = UuidSerializer::class)
+    var oetoRegelReferenzId: Uuid? = null,
+
+    var istAktiv: Boolean = true,
+
+    @Serializable(with = KotlinInstantSerializer::class)
+    val createdAt: Instant = Clock.System.now(),
+    @Serializable(with = KotlinInstantSerializer::class)
+    var updatedAt: Instant = Clock.System.now()
+)

shared/src/commonMain/kotlin/at/mocode/shared/model/stammdaten/BundeslandDefinition.kt

@@ -0,0 +1,51 @@
+package at.mocode.shared.model.stammdaten
+
+import at.mocode.shared.serializers.KotlinInstantSerializer
+import at.mocode.shared.serializers.UuidSerializer
+import com.benasher44.uuid.Uuid
+import com.benasher44.uuid.uuid4
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.serialization.Serializable
+
+/**
+ * Definiert ein Bundesland oder eine vergleichbare subnationale Verwaltungseinheit.
+ *
+ * Diese Entität ist primär für die österreichischen Bundesländer mit ihren OEPS-spezifischen
+ * Codes gedacht, kann aber auch für Bundesländer/Regionen anderer Nationen erweitert werden.
+ *
+ * @property bundeslandId Eindeutiger interner Identifikator für dieses Bundesland (UUID).
+ * @property landId Fremdschlüssel zur `LandDefinition`, dem dieses Bundesland angehört.
+ * @property oepsCode Der 2-stellige numerische OEPS-Code für österreichische Bundesländer
+ * (z.B. "01" für Wien, "02" für Niederösterreich). Sollte eindeutig sein für Land "Österreich".
+ * @property iso3166_2_Code Optionaler offizieller ISO 3166-2 Code für das Bundesland
+ * (z.B. "AT-1" für Burgenland, "DE-BY" für Bayern).
+ * @property name Der offizielle Name des Bundeslandes.
+ * @property kuerzel Ein gängiges Kürzel für das Bundesland (z.B. "NÖ", "W", "STMK").
+ * @property wappenUrl Optionaler URL-Pfad zu einer Bilddatei des Bundeslandwappens.
+ * @property istAktiv Gibt an, ob dieses Bundesland aktuell im System ausgewählt/verwendet werden kann.
+ * @property sortierReihenfolge Optionale Zahl zur Steuerung der Sortierreihenfolge in Auswahllisten.
+ * @property createdAt Zeitstempel der Erstellung dieses Datensatzes.
+ * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes.
+ */
+@Serializable
+data class BundeslandDefinition(
+    @Serializable(with = UuidSerializer::class)
+    val bundeslandId: Uuid = uuid4(),
+
+    @Serializable(with = UuidSerializer::class)
+    var landId: Uuid, // FK zu LandDefinition.landId
+
+    var oepsCode: String?,    // z.B. "01", "02", ... für Österreich; Eindeutig pro landId = Österreich
+    var iso3166_2_Code: String?, // z.B. "AT-1", "DE-BY"; Eindeutig global oder pro Land?
+    var name: String,         // z.B. "Niederösterreich", "Bayern"
+    var kuerzel: String? = null,     // z.B. "NÖ", "BY"
+    var wappenUrl: String? = null,
+    var istAktiv: Boolean = true,
+    var sortierReihenfolge: Int? = null,
+
+    @Serializable(with = KotlinInstantSerializer::class)
+    val createdAt: Instant = Clock.System.now(),
+    @Serializable(with = KotlinInstantSerializer::class)
+    var updatedAt: Instant = Clock.System.now()
+)

shared/src/commonMain/kotlin/at/mocode/shared/model/stammdaten/LandDefinition.kt

@@ -0,0 +1,51 @@
+package at.mocode.shared.model.stammdaten
+
+import at.mocode.shared.serializers.KotlinInstantSerializer
+import at.mocode.shared.serializers.UuidSerializer
+import com.benasher44.uuid.Uuid
+import com.benasher44.uuid.uuid4
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.serialization.Serializable
+
+/**
+ * Definiert ein Land/eine Nation mit seinen offiziellen Codes und Bezeichnungen.
+ *
+ * Diese Entität dient als zentrale Referenz für Länder, die im System für
+ * Nationalitäten von Personen, Vereinen oder für internationale Turniere relevant sind.
+ *
+ * @property landId Eindeutiger interner Identifikator für dieses Land (UUID).
+ * @property isoAlpha2Code Der 2-stellige ISO 3166-1 Alpha-2 Code des Landes (z.B. "AT", "DE"). Sollte eindeutig sein.
+ * @property isoAlpha3Code Der 3-stellige ISO 3166-1 Alpha-3 Code des Landes (z.B. "AUT", "DEU"). Sollte eindeutig sein.
+ * @property isoNumerischerCode Optionaler 3-stelliger numerischer ISO 3166-1 Code des Landes (z.B. "040" für Österreich).
+ * @property nameDeutsch Der offizielle deutsche Name des Landes.
+ * @property nameEnglisch Der offizielle englische Name des Landes.
+ * @property wappenUrl Optionaler URL-Pfad zu einer Bilddatei des Länderwappens oder der Flagge.
+ * @property istEuMitglied Gibt an, ob das Land Mitglied der Europäischen Union ist.
+ * @property istEwrMitglied Gibt an, ob das Land Mitglied des Europäischen Wirtschaftsraums ist.
+ * @property istAktiv Gibt an, ob dieses Land aktuell im System ausgewählt/verwendet werden kann.
+ * @property sortierReihenfolge Optionale Zahl zur Steuerung der Sortierreihenfolge in Auswahllisten.
+ * @property createdAt Zeitstempel der Erstellung dieses Datensatzes.
+ * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes.
+ */
+@Serializable
+data class LandDefinition(
+    @Serializable(with = UuidSerializer::class)
+    val landId: Uuid = uuid4(),
+
+    var isoAlpha2Code: String, // z.B. "AT" -> Fachlicher PK oder Unique Constraint
+    var isoAlpha3Code: String, // z.B. "AUT" -> Unique Constraint
+    var isoNumerischerCode: String? = null, // z.B. "040"
+    var nameDeutsch: String,    // z.B. "Österreich"
+    var nameEnglisch: String? = null, // z.B. "Austria"
+    var wappenUrl: String? = null,
+    var istEuMitglied: Boolean? = null,
+    var istEwrMitglied: Boolean? = null, // Europäischer Wirtschaftsraum
+    var istAktiv: Boolean = true,
+    var sortierReihenfolge: Int? = null,
+
+    @Serializable(with = KotlinInstantSerializer::class)
+    val createdAt: Instant = Clock.System.now(),
+    @Serializable(with = KotlinInstantSerializer::class)
+    var updatedAt: Instant = Clock.System.now()
+)

shared/src/commonMain/kotlin/at/mocode/shared/model/zns_staging/Person_ZNS_Staging.kt

@@ -0,0 +1,67 @@
+package at.mocode.shared.model.zns_staging
+
+import at.mocode.shared.serializers.KotlinInstantSerializer
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.serialization.Serializable
+
+/**
+ * Repräsentiert einen Rohdatensatz für eine Person (Reiter, Funktionär etc.),
+ * wie er aus den OEPS ZNS-Dateien (`LIZENZ01.dat`, `RICHT01.dat`) importiert wird.
+ *
+ * Diese Klasse dient als temporärer Container (Staging-Tabelle) für die unverarbeiteten
+ * Personendaten, bevor sie validiert, transformiert und in die Domänen-Entitäten
+ * `DomPerson` und `DomLizenz` überführt werden. Alle Felder aus der Datei werden
+ * als String oder der direkteste Basistyp gespeichert, um Parsing-Fehler auf dieser
+ * Ebene zu minimieren. Die Konvertierung und Interpretation erfolgt im nächsten Schritt.
+ *
+ * @property oepsSatzNrPerson Die eindeutige OEPS-Satznummer der Person (aus `LIZENZ01.dat` / `RICHT01.dat`, Stelle 1-6). Dient als Primärschlüssel.
+ * @property familiennameRoh Familienname der Person (Rohwert).
+ * @property vornameRoh Vorname der Person (Rohwert).
+ * @property geburtsdatumTextRoh Geburtsdatum als Text im Format JJJJMMTT (Rohwert).
+ * @property geschlechtCodeRoh Geschlechtscode (W, M, " ") (Rohwert).
+ * @property nationalitaetCodeRoh Nationalitätskürzel (3-stellig) (Rohwert).
+ * @property bundeslandCodeOepsRoh OEPS-Code für das Bundesland (Rohwert).
+ * @property vereinsnameOepsRoh Name des Stammvereins (Rohwert).
+ * @property mitgliedNrVereinRoh Mitgliedsnummer im Verein (Rohwert).
+ * @property feiIdPersonRoh FEI-ID der Person (Rohwert).
+ * @property sperrlisteFlagOepsRoh Kennzeichen für Sperrliste ("S" oder BLANK) (Rohwert).
+ * @property kaderFlagOepsRoh Kaderkennzeichen (Rohwert).
+ * @property telefonRoh Telefonnummer (Rohwert).
+ * @property reiterlizenzRoh Kürzel der Haupt-Reiterlizenz (Rohwert).
+ * @property startkarteRoh Kürzel der Startkarte (Rohwert).
+ * @property fahrlizenzRoh Kürzel der Fahrlizenz (Rohwert).
+ * @property altersklasseJugendCodeOepsRoh Code für Altersklasse Jugend/Junior/U25 (Rohwert).
+ * @property altersklasseJungerreiterCodeOepsRoh Code für Altersklasse Junge Reiter ("Y") (Rohwert).
+ * @property jahrLetzteZahlungLizenzOepsRoh Jahr der letzten Lizenzzahlung als Text (Rohwert).
+ * @property lizenzinfoRawOepsRoh Kommagetrennte Liste der bezahlten Lizenzen/Startkarten (Rohwert).
+ * @property qualifikationenRawOepsRoh Kommagetrennte Liste der Funktionärsqualifikationen aus `RICHT01.dat` (Rohwert).
+ * @property importTimestamp Zeitstempel, wann dieser Datensatz in die Staging-Tabelle importiert wurde.
+ */
+@Serializable
+data class Person_ZNS_Staging(
+    val oepsSatzNrPerson: String, // PK aus LIZENZ01.dat / RICHT01.dat (VARCHAR(6))
+    var familiennameRoh: String?,     // VARCHAR(50)
+    var vornameRoh: String?,           // VARCHAR(25)
+    var geburtsdatumTextRoh: String?,  // VARCHAR(8) (JJJJMMTT)
+    var geschlechtCodeRoh: String?,    // CHAR(1)
+    var nationalitaetCodeRoh: String?, // VARCHAR(3)
+    var bundeslandCodeOepsRoh: String?,// VARCHAR(2)
+    var vereinsnameOepsRoh: String?,    // VARCHAR(50)
+    var mitgliedNrVereinRoh: String?,   // VARCHAR(8)
+    var feiIdPersonRoh: String?,        // VARCHAR(10)
+    var sperrlisteFlagOepsRoh: String?,// CHAR(1)
+    var kaderFlagOepsRoh: String?,      // CHAR(1)
+    var telefonRoh: String?,           // VARCHAR(21)
+    var reiterlizenzRoh: String?,      // VARCHAR(4)
+    var startkarteRoh: String?,        // CHAR(1)
+    var fahrlizenzRoh: String?,        // VARCHAR(2)
+    var altersklasseJugendCodeOepsRoh: String?, // VARCHAR(2)
+    var altersklasseJungerreiterCodeOepsRoh: String?, // CHAR(1)
+    var jahrLetzteZahlungLizenzOepsRoh: String?, // VARCHAR(4) -> wird zu Int?
+    var lizenzinfoRawOepsRoh: String?,          // VARCHAR(10)
+    var qualifikationenRawOepsRoh: String?,    // VARCHAR(30) aus RICHT01.dat
+    @Serializable(with = KotlinInstantSerializer::class)
+    var importTimestamp: Instant = Clock.System.now()
+)
+

shared/src/commonMain/kotlin/at/mocode/shared/model/zns_staging/Pferd_ZNS_Staging.kt

@@ -0,0 +1,50 @@
+package at.mocode.shared.model.zns_staging
+
+import at.mocode.shared.serializers.KotlinInstantSerializer
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.serialization.Serializable
+
+/**
+ * Repräsentiert einen Rohdatensatz für ein Pferd, wie er aus der OEPS ZNS-Datei
+ * `PFERDE01.dat` importiert wird.
+ *
+ * Diese Klasse dient als temporärer Container (Staging-Tabelle) für die unverarbeiteten
+ * Pferdedaten, bevor sie validiert, transformiert und in die Domänen-Entität
+ * `DomPferd` überführt werden. Alle Felder aus der Datei werden als String oder
+ * der direkteste Basistyp gespeichert.
+ *
+ * @property oepsSatzNrPferd Die eindeutige 10-stellige OEPS-Satznummer des Pferdes (aus `PFERDE01.dat`). Dient als Primärschlüssel.
+ * @property oepsKopfNrRoh Die 4-stellige OEPS-Kopfnummer des Pferdes (Rohwert).
+ * @property nameRoh Name des Pferdes (Rohwert).
+ * @property lebensnummerRoh Lebensnummer des Pferdes (Rohwert).
+ * @property geburtsjahrRoh Geburtsjahr des Pferdes als Text (Rohwert).
+ * @property geschlechtCodeRoh Geschlechtscode des Pferdes (Rohwert).
+ * @property farbeRoh Farbe des Pferdes (Rohwert).
+ * @property abstammungVaterNameRoh Name des Vaters (Rohwert).
+ * @property abstammungInfoRoh Allgemeines Abstammungsfeld (Muttervater etc.) (Rohwert).
+ * @property oepsVereinNrPferdRoh OEPS-Vereinsnummer des Heimatvereins des Pferdes (Rohwert).
+ * @property verantwortlichePersonNameRoh Name der verantwortlichen Person für das Pferd (Rohwert).
+ * @property feiPassNrRoh FEI-Passnummer des Pferdes (Rohwert).
+ * @property letzteZahlungPferdegebuehrJahrRoh Jahr der letzten Zahlung der Pferdegebühr als Text (Rohwert).
+ * @property importTimestamp Zeitstempel, wann dieser Datensatz in die Staging-Tabelle importiert wurde.
+ */
+@Serializable
+data class Pferd_ZNS_Staging(
+    val oepsSatzNrPferd: String, // PK aus PFERDE01.dat (VARCHAR(10))
+    var oepsKopfNrRoh: String?,      // VARCHAR(4)
+    var nameRoh: String?,           // VARCHAR(30)
+    var lebensnummerRoh: String?,   // VARCHAR(9)
+    var geburtsjahrRoh: String?,      // VARCHAR(4) -> wird zu Int?
+    var geschlechtCodeRoh: String?,   // CHAR(1)
+    var farbeRoh: String?,           // VARCHAR(15)
+    var abstammungVaterNameRoh: String?,// VARCHAR(30)
+    var abstammungInfoRoh: String?,    // VARCHAR(15) (allgemeines Abstammungsfeld)
+    var oepsVereinNrPferdRoh: String?, // VARCHAR(4)
+    var verantwortlichePersonNameRoh: String?, // VARCHAR(75)
+    var feiPassNrRoh: String?,         // VARCHAR(10)
+    var letzteZahlungPferdegebuehrJahrRoh: String?, // VARCHAR(4) -> wird zu Int?
+    @Serializable(with = KotlinInstantSerializer::class)
+    var importTimestamp: Instant = Clock.System.now()
+)
+

shared/src/commonMain/kotlin/at/mocode/shared/model/zns_staging/Verein_ZNS_Staging.kt

@@ -0,0 +1,27 @@
+package at.mocode.shared.model.zns_staging
+
+import at.mocode.shared.serializers.KotlinInstantSerializer
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.serialization.Serializable
+
+/**
+ * Repräsentiert einen Rohdatensatz für einen Verein, wie er aus der OEPS ZNS-Datei
+ * `VEREIN01.dat` importiert wird.
+ *
+ * Diese Klasse dient als temporärer Container (Staging-Tabelle) für die unverarbeiteten
+ * Vereinsdaten, bevor sie validiert, transformiert und in die Domänen-Entität
+ * `DomVerein` überführt werden.
+ *
+ * @property oepsVereinsNr Die offizielle OEPS-Vereinsnummer (aus `VEREIN01.dat`, Stelle 1-4). Dient als Primärschlüssel für diesen Staging-Datensatz.
+ * @property nameRoh Der Name des Vereins, wie er in der `VEREIN01.dat` (Stelle 5-54) steht.
+ * @property importTimestamp Zeitstempel, wann dieser Datensatz in die Staging-Tabelle importiert wurde.
+ */
+@Serializable
+data class Verein_ZNS_Staging(
+    val oepsVereinsNr: String, // PK aus VEREIN01.dat (VARCHAR(4))
+    var nameRoh: String?,      // VARCHAR(50)
+    @Serializable(with = KotlinInstantSerializer::class)
+    var importTimestamp: Instant = Clock.System.now()
+)
+

shared/src/commonMain/kotlin/at/mocode/shared/stammdaten/LizenzInfo.kt

@@ -1,7 +1,7 @@
 package at.mocode.shared.stammdaten
 
 import at.mocode.shared.enums.LizenzTyp
-import at.mocode.shared.enums.Sparte
+import at.mocode.shared.enums.SparteE
 import at.mocode.shared.serializers.KotlinLocalDateSerializer
 import kotlinx.datetime.LocalDate
 import kotlinx.serialization.Serializable
@@ -10,7 +10,7 @@ import kotlinx.serialization.Serializable
 data class LizenzInfo(
     val lizenzTyp: LizenzTyp,
     val stufe: String?,
-    val sparte: Sparte?,
+    val sparteE: SparteE?,
     val gueltigBisJahr: Int?, // Jahr als Int
     @Serializable(with = KotlinLocalDateSerializer::class)
     val ausgestelltAm: LocalDate?

shared/src/commonTest/kotlin/at/mocode/shared/enums/EnumsTest.kt

@@ -87,40 +87,40 @@ class EnumsTest {
     @Test
     fun testSparteEnum() {
         // Test all enum values
-        val values = Sparte.entries.toTypedArray()
+        val values = SparteE.entries.toTypedArray()
         assertEquals(12, values.size)
 
         // Test specific enum values
-        assertEquals(Sparte.DRESSUR, values[0])
-        assertEquals(Sparte.SPRINGEN, values[1])
-        assertEquals(Sparte.VIELSEITIGKEIT, values[2])
-        assertEquals(Sparte.FAHREN, values[3])
-        assertEquals(Sparte.VOLTIGIEREN, values[4])
-        assertEquals(Sparte.WESTERN, values[5])
-        assertEquals(Sparte.DISTANZ, values[6])
-        assertEquals(Sparte.ISLAND, values[7])
-        assertEquals(Sparte.PFERDESPORT_SPIEL, values[8])
-        assertEquals(Sparte.BASIS, values[9])
-        assertEquals(Sparte.KOMBINIERT, values[10])
-        assertEquals(Sparte.SONSTIGES, values[11])
+        assertEquals(SparteE.DRESSUR, values[0])
+        assertEquals(SparteE.SPRINGEN, values[1])
+        assertEquals(SparteE.VIELSEITIGKEIT, values[2])
+        assertEquals(SparteE.FAHREN, values[3])
+        assertEquals(SparteE.VOLTIGIEREN, values[4])
+        assertEquals(SparteE.WESTERN, values[5])
+        assertEquals(SparteE.DISTANZ, values[6])
+        assertEquals(SparteE.ISLAND, values[7])
+        assertEquals(SparteE.PFERDESPORT_SPIEL, values[8])
+        assertEquals(SparteE.BASIS, values[9])
+        assertEquals(SparteE.KOMBINIERT, values[10])
+        assertEquals(SparteE.SONSTIGES, values[11])
 
         // Test serialization and deserialization
-        testEnumSerialization(Sparte.DRESSUR)
-        testEnumSerialization(Sparte.SPRINGEN)
-        testEnumSerialization(Sparte.VIELSEITIGKEIT)
-        testEnumSerialization(Sparte.FAHREN)
-        testEnumSerialization(Sparte.VOLTIGIEREN)
-        testEnumSerialization(Sparte.WESTERN)
-        testEnumSerialization(Sparte.DISTANZ)
-        testEnumSerialization(Sparte.ISLAND)
-        testEnumSerialization(Sparte.PFERDESPORT_SPIEL)
-        testEnumSerialization(Sparte.BASIS)
-        testEnumSerialization(Sparte.KOMBINIERT)
-        testEnumSerialization(Sparte.SONSTIGES)
+        testEnumSerialization(SparteE.DRESSUR)
+        testEnumSerialization(SparteE.SPRINGEN)
+        testEnumSerialization(SparteE.VIELSEITIGKEIT)
+        testEnumSerialization(SparteE.FAHREN)
+        testEnumSerialization(SparteE.VOLTIGIEREN)
+        testEnumSerialization(SparteE.WESTERN)
+        testEnumSerialization(SparteE.DISTANZ)
+        testEnumSerialization(SparteE.ISLAND)
+        testEnumSerialization(SparteE.PFERDESPORT_SPIEL)
+        testEnumSerialization(SparteE.BASIS)
+        testEnumSerialization(SparteE.KOMBINIERT)
+        testEnumSerialization(SparteE.SONSTIGES)
 
         // Test comparison
-        assertEquals(Sparte.DRESSUR, Sparte.DRESSUR)
-        assertNotEquals(Sparte.DRESSUR, Sparte.SPRINGEN)
+        assertEquals(SparteE.DRESSUR, SparteE.DRESSUR)
+        assertNotEquals(SparteE.DRESSUR, SparteE.SPRINGEN)
     }
 
     @Test
@@ -455,7 +455,7 @@ class EnumsTest {
     }
 
     // Test serialization for a specific enum value
-    private fun testEnumSerialization(value: Sparte) {
+    private fun testEnumSerialization(value: SparteE) {
         val json = Json { prettyPrint = true }
         val jsonString = json.encodeToString(value)
 
@@ -463,7 +463,7 @@ class EnumsTest {
         assertEquals("\"${value.name}\"", jsonString)
 
         // Verify deserialization
-        val deserializedValue = json.decodeFromString<Sparte>(jsonString)
+        val deserializedValue = json.decodeFromString<SparteE>(jsonString)
         assertEquals(value, deserializedValue)
     }
 

shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/LizenzInfoTest.kt

@@ -1,7 +1,7 @@
 package at.mocode.shared.stammdaten
 
 import at.mocode.shared.enums.LizenzTyp
-import at.mocode.shared.enums.Sparte
+import at.mocode.shared.enums.SparteE
 import kotlinx.datetime.LocalDate
 import kotlinx.serialization.json.Json
 import kotlin.test.Test
@@ -16,7 +16,7 @@ class LizenzInfoTest {
         val lizenzInfo = LizenzInfo(
             lizenzTyp = LizenzTyp.REITER,
             stufe = null,
-            sparte = null,
+            sparteE = null,
             gueltigBisJahr = null,
             ausgestelltAm = null
         )
@@ -26,7 +26,7 @@ class LizenzInfoTest {
 
         // Verify optional fields are null
         assertEquals(null, lizenzInfo.stufe)
-        assertEquals(null, lizenzInfo.sparte)
+        assertEquals(null, lizenzInfo.sparteE)
         assertEquals(null, lizenzInfo.gueltigBisJahr)
         assertEquals(null, lizenzInfo.ausgestelltAm)
     }
@@ -39,7 +39,7 @@ class LizenzInfoTest {
         val lizenzInfo = LizenzInfo(
             lizenzTyp = LizenzTyp.FAHRER,
             stufe = "A",
-            sparte = Sparte.DRESSUR,
+            sparteE = SparteE.DRESSUR,
             gueltigBisJahr = 2024,
             ausgestelltAm = ausgestelltAm
         )
@@ -47,7 +47,7 @@ class LizenzInfoTest {
         // Verify all fields
         assertEquals(LizenzTyp.FAHRER, lizenzInfo.lizenzTyp)
         assertEquals("A", lizenzInfo.stufe)
-        assertEquals(Sparte.DRESSUR, lizenzInfo.sparte)
+        assertEquals(SparteE.DRESSUR, lizenzInfo.sparteE)
         assertEquals(2024, lizenzInfo.gueltigBisJahr)
         assertEquals(ausgestelltAm, lizenzInfo.ausgestelltAm)
     }
@@ -60,7 +60,7 @@ class LizenzInfoTest {
         val lizenzInfo = LizenzInfo(
             lizenzTyp = LizenzTyp.VOLTIGIERER,
             stufe = "B",
-            sparte = Sparte.VOLTIGIEREN,
+            sparteE = SparteE.VOLTIGIEREN,
             gueltigBisJahr = 2025,
             ausgestelltAm = ausgestelltAm
         )
@@ -90,7 +90,7 @@ class LizenzInfoTest {
         // Verify deserialized object matches original
         assertEquals(lizenzInfo.lizenzTyp, deserializedLizenzInfo.lizenzTyp)
         assertEquals(lizenzInfo.stufe, deserializedLizenzInfo.stufe)
-        assertEquals(lizenzInfo.sparte, deserializedLizenzInfo.sparte)
+        assertEquals(lizenzInfo.sparteE, deserializedLizenzInfo.sparteE)
         assertEquals(lizenzInfo.gueltigBisJahr, deserializedLizenzInfo.gueltigBisJahr)
         assertEquals(lizenzInfo.ausgestelltAm, deserializedLizenzInfo.ausgestelltAm)
     }
@@ -101,7 +101,7 @@ class LizenzInfoTest {
         val original = LizenzInfo(
             lizenzTyp = LizenzTyp.WESTERN,
             stufe = "C",
-            sparte = Sparte.WESTERN,
+            sparteE = SparteE.WESTERN,
             gueltigBisJahr = 2023,
             ausgestelltAm = null
         )
@@ -115,7 +115,7 @@ class LizenzInfoTest {
 
         // Verify copied properties
         assertEquals(original.lizenzTyp, copy.lizenzTyp)
-        assertEquals(original.sparte, copy.sparte)
+        assertEquals(original.sparteE, copy.sparteE)
 
         // Verify modified properties
         assertEquals("B", copy.stufe)
@@ -148,7 +148,7 @@ class LizenzInfoTest {
             val lizenzInfo = LizenzInfo(
                 lizenzTyp = lizenzTyp,
                 stufe = "Test",
-                sparte = Sparte.SONSTIGES,
+                sparteE = SparteE.SONSTIGES,
                 gueltigBisJahr = 2024,
                 ausgestelltAm = null
             )

shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/PersonTest.kt

@@ -3,7 +3,7 @@ package at.mocode.shared.stammdaten
 import at.mocode.shared.enums.FunktionaerRolle
 import at.mocode.shared.enums.Geschlecht
 import at.mocode.shared.enums.LizenzTyp
-import at.mocode.shared.enums.Sparte
+import at.mocode.shared.enums.SparteE
 import com.benasher44.uuid.uuid4
 import kotlinx.datetime.Clock
 import kotlinx.datetime.LocalDate
@@ -83,7 +83,7 @@ class PersonTest {
             LizenzInfo(
                 lizenzTyp = LizenzTyp.REITER,
                 stufe = "A",
-                sparte = Sparte.SPRINGEN,
+                sparteE = SparteE.SPRINGEN,
                 gueltigBisJahr = 2024,
                 ausgestelltAm = null
             )
@@ -180,7 +180,7 @@ class PersonTest {
             LizenzInfo(
                 lizenzTyp = LizenzTyp.FAHRER,
                 stufe = "B",
-                sparte = Sparte.DRESSUR,
+                sparteE = SparteE.DRESSUR,
                 gueltigBisJahr = 2025,
                 ausgestelltAm = null
             )
@@ -250,7 +250,7 @@ class PersonTest {
             LizenzInfo(
                 lizenzTyp = LizenzTyp.REITER,
                 stufe = "A",
-                sparte = Sparte.SPRINGEN,
+                sparteE = SparteE.SPRINGEN,
                 gueltigBisJahr = 2024,
                 ausgestelltAm = null
             )